public void PostingWarningCollection_WhenCalculateAsyncHasNotBeenCalledOnPostingJournalResult_ReturnsPostingWarningCollection()
{
IPostingJournalResult sut = CreateSut();
IPostingWarningCollection result = sut.PostingWarningCollection;
Assert.That(result, Is.TypeOf <Domain.Accounting.PostingWarningCollection>());
}
public async Task CalculateAsync_WhenCalled_ReturnsSamePostingJournalResult()
{
IPostingJournalResult sut = CreateSut();
IPostingJournalResult result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
Assert.That(result, Is.SameAs(sut));
}
public void PostingWarningCollection_WhenCalculateAsyncHasNotBeenCalledOnPostingJournalResult_ReturnsEmptyPostingWarningCollection()
{
IPostingJournalResult sut = CreateSut();
IPostingWarningCollection result = sut.PostingWarningCollection;
Assert.That(result, Is.Empty);
}
public async Task ExecuteAsync_WhenPostingJournalResultWasReturnedFromAccountingRepository_ReturnsNotNull()
{
CommandHandler sut = CreateSut();
IApplyPostingJournalCommand applyPostingJournalCommand = CreateApplyPostingJournalCommand();
IPostingJournalResult result = await sut.ExecuteAsync(applyPostingJournalCommand);
Assert.That(result, Is.Not.Null);
}
public async Task ExecuteAsync_WhenNoPostingJournalResultWasReturnedFromAccountingRepository_ReturnsCalculatedPostingJournalResult()
{
CommandHandler sut = CreateSut(false);
IApplyPostingJournalCommand applyPostingJournalCommand = CreateApplyPostingJournalCommand();
IPostingJournalResult result = await sut.ExecuteAsync(applyPostingJournalCommand);
Assert.That(result.StatusDate, Is.EqualTo(DateTime.Today));
}
public async Task ExecuteAsync_WhenNoPostingJournalResultWasReturnedFromAccountingRepository_ReturnsPostingJournalResultWherePostingWarningCollectionIsNotNull()
{
CommandHandler sut = CreateSut(false);
IApplyPostingJournalCommand applyPostingJournalCommand = CreateApplyPostingJournalCommand();
IPostingJournalResult result = await sut.ExecuteAsync(applyPostingJournalCommand);
Assert.That(result.PostingWarningCollection, Is.Not.Null);
}
public async Task ExecuteAsync_WhenNoPostingJournalResultWasReturnedFromAccountingRepository_ReturnsPostingJournalResult()
{
CommandHandler sut = CreateSut(false);
IApplyPostingJournalCommand applyPostingJournalCommand = CreateApplyPostingJournalCommand();
IPostingJournalResult result = await sut.ExecuteAsync(applyPostingJournalCommand);
Assert.That(result, Is.TypeOf <PostingJournalResult>());
}
public async Task CalculateAsync_WhenCalled_ReturnsSamePostingJournalResultWherePostingLineCollectionIsEqualToCalculatedPostingLineCollection()
{
IPostingLineCollection calculatedPostingLineCollection = _fixture.BuildPostingLineCollectionMock(isEmpty: true).Object;
IPostingLineCollection postingLineCollection = _fixture.BuildPostingLineCollectionMock(calculatedPostingLineCollection: calculatedPostingLineCollection, isEmpty: true).Object;
IPostingJournalResult sut = CreateSut(postingLineCollection);
IPostingJournalResult result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
Assert.That(result.PostingLineCollection, Is.SameAs(calculatedPostingLineCollection));
}
public async Task CalculateAsync_WhenCalled_ReturnsSamePostingJournalResultWherePostingWarningCollectionIsEqualToPostingWarningCollectionFromPostingWarningCalculator()
{
IPostingWarningCollection postingWarningCollection = _fixture.BuildPostingWarningCollectionMock().Object;
IPostingWarningCalculator postingWarningCalculator = _fixture.BuildPostingWarningCalculatorMock(postingWarningCollection).Object;
IPostingJournalResult sut = CreateSut(postingWarningCalculator: postingWarningCalculator);
IPostingJournalResult result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
Assert.That(result.PostingWarningCollection, Is.SameAs(postingWarningCollection));
}
public async Task ExecuteAsync_WhenNoPostingJournalResultWasReturnedFromAccountingRepository_ReturnsPostingJournalResultWherePostingWarningCollectionEqualToPostingWarningCollectionFromPostingWarningCalculator()
{
IPostingWarningCollection postingWarningCollection = _fixture.BuildPostingWarningCollectionMock(isEmpty: true).Object;
CommandHandler sut = CreateSut(false, postingWarningCollection: postingWarningCollection);
IApplyPostingJournalCommand applyPostingJournalCommand = CreateApplyPostingJournalCommand();
IPostingJournalResult result = await sut.ExecuteAsync(applyPostingJournalCommand);
Assert.That(result.PostingWarningCollection, Is.EqualTo(postingWarningCollection));
}
public async Task CalculateAsync_WhenCalled_AssertCalculateAsyncWasCalledOnPostingLineCollection()
{
Mock <IPostingLineCollection> postingLineCollectionMock = _fixture.BuildPostingLineCollectionMock(isEmpty: true);
IPostingJournalResult sut = CreateSut(postingLineCollectionMock.Object);
DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
await sut.CalculateAsync(statusDate);
postingLineCollectionMock.Verify(m => m.CalculateAsync(It.Is <DateTime>(value => value == statusDate.Date)), Times.Once);
}
private CommandHandler CreateSut(bool hasPostingJournalResult = true, IPostingJournalResult postingJournalResult = null, IPostingWarningCollection postingWarningCollection = null)
{
_accountingRepositoryMock.Setup(m => m.ApplyPostingJournalAsync(It.IsAny <IPostingJournal>(), It.IsAny <IPostingWarningCalculator>()))
.Returns(Task.FromResult(hasPostingJournalResult ? postingJournalResult ?? _fixture.BuildPostingJournalResultMock().Object : null));
_postingWarningCalculatorMock.Setup(m => m.CalculateAsync(It.IsAny <IPostingLineCollection>()))
.Returns(Task.FromResult(postingWarningCollection ?? _fixture.BuildPostingWarningCollectionMock(isEmpty: true).Object));
return(new CommandHandler(_validatorMock.Object, _accountingRepositoryMock.Object, _commonRepositoryMock.Object, _postingWarningCalculatorMock.Object));
}
public async Task ExecuteAsync_WhenPostingJournalResultWasReturnedFromAccountingRepository_ReturnsCalculatedPostingJournalResult()
{
IPostingJournalResult calculatedPostingJournalResult = _fixture.BuildPostingJournalResultMock().Object;
IPostingJournalResult postingJournalResult = _fixture.BuildPostingJournalResultMock(calculatedPostingJournalResult: calculatedPostingJournalResult).Object;
CommandHandler sut = CreateSut(postingJournalResult: postingJournalResult);
IApplyPostingJournalCommand applyPostingJournalCommand = CreateApplyPostingJournalCommand();
IPostingJournalResult result = await sut.ExecuteAsync(applyPostingJournalCommand);
Assert.That(result, Is.EqualTo(calculatedPostingJournalResult));
}
private async Task <ActionResult <ApplyPostingJournalResultModel> > ApplyPostingJournalAsync(IApplyPostingJournalCommand applyPostingJournalCommand)
{
NullGuard.NotNull(applyPostingJournalCommand, nameof(applyPostingJournalCommand));
IPostingJournalResult postingJournalResult = await _commandBus.PublishAsync <IApplyPostingJournalCommand, IPostingJournalResult>(applyPostingJournalCommand);
ApplyPostingJournalResultModel applyPostingJournalResultModel = postingJournalResult == null
? BuildEmptyApplyPostingJournalResultModel()
: _accountingModelConverter.Convert <IPostingJournalResult, ApplyPostingJournalResultModel>(postingJournalResult);
return(Ok(applyPostingJournalResultModel));
}
public async Task ApplyPostingJournalAsync_WhenPublishAsyncForApplyPostingJournalCommandReturnsPostingJournalResult_ReturnsOkObjectResultWhereValueIsApplyPostingJournalResultModelWithSameAmountOfPostingWarningsAsPostingWarningsInPostingJournalResult()
{
IPostingWarning[] postingWarnings = _fixture.CreateMany <IPostingWarning>(_random.Next(10, 25)).ToArray();
IPostingWarningCollection postingWarningCollection = _fixture.BuildPostingWarningCollectionMock(postingWarnings).Object;
IPostingJournalResult postingJournalResult = _fixture.BuildPostingJournalResultMock(postingWarningCollection: postingWarningCollection).Object;
Controller sut = CreateSut(postingJournalResult: postingJournalResult);
OkObjectResult result = (OkObjectResult)(await sut.ApplyPostingJournalAsync(CreateApplyPostingJournalModel())).Result;
ApplyPostingJournalResultModel applyPostingJournalResultModel = (ApplyPostingJournalResultModel)result.Value;
Assert.That(applyPostingJournalResultModel.PostingWarnings.Count, Is.EqualTo(postingWarnings.Length));
}
private Controller CreateSut(bool hasPostingJournalResult = true, IPostingJournalResult postingJournalResult = null, bool modelIsValid = true, string errorKey = null, string errorMessage = null)
{
_commandBusMock.Setup(m => m.PublishAsync <IApplyPostingJournalCommand, IPostingJournalResult>(It.IsAny <IApplyPostingJournalCommand>()))
.Returns(Task.FromResult(hasPostingJournalResult ? postingJournalResult ?? _fixture.BuildPostingJournalResultMock().Object : null));
Controller controller = new Controller(_commandBusMock.Object, _queryBusMock.Object);
if (modelIsValid == false)
{
controller.ModelState.AddModelError(errorKey ?? _fixture.Create <string>(), errorMessage ?? _fixture.Create <string>());
}
return(controller);
}
public async Task ApplyPostingJournalAsync_WhenPublishAsyncForApplyPostingJournalCommandReturnsPostingJournalResult_ReturnsOkObjectResultWhereValueIsApplyPostingJournalResultModelWherePostingWarningsContainsMappedPostingWarningsFromPostingJournalResult()
{
IPostingWarning[] postingWarnings = _fixture.CreateMany <IPostingWarning>(_random.Next(10, 25)).ToArray();
IPostingWarningCollection postingWarningCollection = _fixture.BuildPostingWarningCollectionMock(postingWarnings).Object;
IPostingJournalResult postingJournalResult = _fixture.BuildPostingJournalResultMock(postingWarningCollection: postingWarningCollection).Object;
Controller sut = CreateSut(postingJournalResult: postingJournalResult);
OkObjectResult result = (OkObjectResult)(await sut.ApplyPostingJournalAsync(CreateApplyPostingJournalModel())).Result;
ApplyPostingJournalResultModel applyPostingJournalResultModel = (ApplyPostingJournalResultModel)result.Value;
Assert.That(applyPostingJournalResultModel.PostingWarnings.All(postingWarningModel => postingWarnings.Any(postingWarning => IsMatch(postingWarningModel, postingWarning))), Is.True);
}
public async Task CalculateAsync_WhenCalledMultipleTimesWithSameStatusDate_AssertCalculateAsyncWasCalledOnlyOnceOnPostingWarningCalculatorWithCalculatedPostingLineCollection()
{
IPostingLineCollection calculatedPostingLineCollection = _fixture.BuildPostingLineCollectionMock(isEmpty: true).Object;
IPostingLineCollection postingLineCollection = _fixture.BuildPostingLineCollectionMock(calculatedPostingLineCollection: calculatedPostingLineCollection, isEmpty: true).Object;
Mock <IPostingWarningCalculator> postingWarningCalculatorMock = _fixture.BuildPostingWarningCalculatorMock(isEmpty: true);
IPostingJournalResult sut = CreateSut(postingLineCollection, postingWarningCalculatorMock.Object);
DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
await(await(await sut.CalculateAsync(statusDate)).CalculateAsync(statusDate)).CalculateAsync(statusDate);
postingWarningCalculatorMock.Verify(m => m.CalculateAsync(It.Is <IPostingLineCollection>(value => value == calculatedPostingLineCollection)), Times.Once);
}
public async Task ApplyPostingJournalAsync_WhenCalled_ReturnsNonEmptyPostingJournalResult()
{
IAccountingRepository sut = CreateSut();
IPostingJournal postingJournal = await BuildPostingJournalAsync(sut);
IPostingWarningCalculator postingWarningCalculator = await BuildPostingWarningCalculator();
IPostingJournalResult result = await sut.ApplyPostingJournalAsync(postingJournal, postingWarningCalculator);
Assert.That(result, Is.Not.Null);
Assert.That(result.PostingLineCollection, Is.Not.Null);
Assert.That(result.PostingLineCollection, Is.Not.Empty);
Assert.That(result.PostingLineCollection.Count(), Is.EqualTo(postingJournal.PostingLineCollection.Count()));
Assert.That(result.PostingWarningCollection, Is.Not.Null);
Assert.That(result.PostingWarningCollection, Is.Empty);
}
