public MessageEnvelope(
string message = null,
NotificationTransaction transaction = null)
{
Message = message;
Transaction = transaction;
}
public async Task GetNotificationDatesSummaryByIdChecksAuthorization()
{
var notification = NotificationApplicationFactory.Create(userId, NotificationType.Recovery,
UKCompetentAuthority.England, 20181);
context.NotificationApplications.Add(notification);
context.SaveChanges();
var notificationId = notification.Id;
var decisionRequiredBy = new DecisionRequiredBy(A.Fake <IDecisionRequiredByCalculator>(),
A.Fake <IFacilityRepository>());
var assessmentRepository = A.Fake <INotificationAssessmentRepository>();
var applicationRepository = A.Fake <INotificationApplicationRepository>();
var transactionCalculator = A.Fake <INotificationTransactionCalculator>();
var assessment = new NotificationAssessment(notificationId);
ObjectInstantiator <NotificationAssessment> .SetProperty(x => x.Status, NotificationStatus.NotificationReceived, assessment);
A.CallTo(() => assessmentRepository.GetByNotificationId(notificationId))
.Returns(assessment);
A.CallTo(() => applicationRepository.GetById(notificationId)).Returns(notification);
var transaction = new NotificationTransaction(
new NotificationTransactionData
{
Credit = 1,
Date = new DateTime(2017, 1, 1),
NotificationId = notificationId,
PaymentMethod = PaymentMethod.Card
});
A.CallTo(() => transactionCalculator.PaymentReceivedDate(notificationId))
.Returns(transaction);
A.CallTo(() => transactionCalculator.LatestPayment(notificationId))
.Returns(transaction);
A.CallTo(() => transactionCalculator.IsPaymentComplete(notificationId)).Returns(true);
var repository = new NotificationAssessmentDatesSummaryRepository(decisionRequiredBy,
assessmentRepository,
applicationRepository,
transactionCalculator,
notificationApplicationAuthorization);
await repository.GetById(notificationId);
A.CallTo(() => notificationApplicationAuthorization.EnsureAccessAsync(notificationId)).MustHaveHappened();
context.DeleteOnCommit(notification);
await context.SaveChangesAsync();
}
public async Task ItShouldReturnTheExpectedResultWhenNoExceptionIsThrown(
NotificationTransaction expectedTransaction,
AbstractMessageProcessor <long> sut)
{
// Arrange
var expected =
new MessageEnvelope("Notifications Commited", expectedTransaction)
.AsSource()
.OfLikeness <MessageEnvelope>()
.CreateProxy();
// Act
var actual = await sut.GetMessages(CancellationToken.None);
// Assert
expected.Should().Be(actual);
}
public async Task ItShouldStoreTheExpectedMessagesWhenNoExceptionIsThrown(
[Frozen] IStorageProvider <long> storageProvider,
[Frozen] IStorageMessageSerializer serializer,
CancellationToken cancellation,
NotificationTransaction expectedTransaction,
INotification <long>[] expectedNotifications,
INotificationChannel <long> channel,
AbstractMessageProcessor <long> sut)
{
// Arrange
// Act
await sut.GetMessages(cancellation);
// Assert
A.CallTo(() => storageProvider.Store(serializer, expectedNotifications)).MustHaveHappened(Repeated.Exactly.Once)
.Then(A.CallTo(() => channel.Commit(expectedNotifications, expectedTransaction)).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task ItShouldRollbackTheExpectedMessagesWhenAnExceptionIsThrown(
[Frozen] IStorageProvider <long> storageProvider,
NotificationTransaction expectedTransaction,
INotification <long>[] expectedNotifications,
INotificationChannel <long> channel,
AbstractMessageProcessor <long> sut)
{
// Arrange
A.CallTo(() => storageProvider.Store(
A <IStorageMessageSerializer> ._,
A <INotification <long>[]> ._))
.Throws <Exception>();
// Act
await sut.GetMessages(CancellationToken.None);
// Assert
A.CallTo(() => channel.Commit(A <INotification <long>[]> ._, A <NotificationTransaction> ._)).MustNotHaveHappened();
A.CallTo(() => channel.Rollback(expectedNotifications, expectedTransaction)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task ItShouldReturnTheExpectedResultWhenAnExceptionIsThrown(
[Frozen] IStorageProvider <long> storageProvider,
NotificationTransaction expectedTransaction,
Exception exception,
AbstractMessageProcessor <long> sut)
{
// Arrange
A.CallTo(() => storageProvider.Store(
A <IStorageMessageSerializer> ._,
A <INotification <long>[]> ._))
.Throws(exception);
var likeness =
new MessageEnvelope(exception.Message, expectedTransaction)
.AsSource()
.OfLikeness <MessageEnvelope>();
// Act
var actual = await sut.GetMessages(CancellationToken.None);
// Assert
likeness.ShouldEqual(actual);
}
public void Add(NotificationTransaction notificationTransaction)
{
context.NotificationTransactions.Add(notificationTransaction);
}
