public async Task CalculateAsync_WhenCalled_AssertCalculateAsyncWasCalledOnEachAccount()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            IEnumerable <Mock <IAccount> > accountMockCollection = new List <Mock <IAccount> >
            {
                _fixture.BuildAccountMock(),
                                           _fixture.BuildAccountMock(),
                                           _fixture.BuildAccountMock(),
                                           _fixture.BuildAccountMock(),
                                           _fixture.BuildAccountMock(),
                                           _fixture.BuildAccountMock(),
                                           _fixture.BuildAccountMock()
            };

            sut.Add(accountMockCollection.Select(accountMock => accountMock.Object).ToArray());

            DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
            await sut.CalculateAsync(statusDate);

            foreach (Mock <IAccount> accountMock in accountMockCollection)
            {
                accountMock.Verify(m => m.CalculateAsync(It.Is <DateTime>(value => value == statusDate.Date)), Times.Once);
            }
        }
        public async Task CalculateAsync_WhenCalled_AssertCalculateWasCalledOnSut()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            Sut result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));

            Assert.That(result.CalculateWasCalled, Is.True);
        }
        public async Task CalculateAsync_WhenCalled_ReturnsSameAccountCollectionBase()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            IAccountCollectionBase <IAccount, Sut> result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));

            Assert.That(result, Is.SameAs(sut));
        }
        public async Task CalculateAsync_WhenCalled_AssertCalculateWasCalledWithSameStatusDate()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
            Sut      result     = await sut.CalculateAsync(statusDate);

            Assert.That(result.CalculateCalledWithStatusDate, Is.EqualTo(statusDate.Date));
        }
        public async Task CalculateAsync_WhenCalled_ReturnsSameAccountCollectionBaseWhereStatusDateEqualDateFromCall()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
            IAccountCollectionBase <IAccount, Sut> result = await sut.CalculateAsync(statusDate);

            Assert.That(result.StatusDate, Is.EqualTo(statusDate.Date));
        }
        public async Task CalculateAsync_WhenCalled_AssertCalculateWasCalledWithCalculatedAccountCollection()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            IEnumerable <IAccount> calculatedAccountCollection = new List <IAccount>
            {
                _fixture.BuildAccountMock().Object,
                                   _fixture.BuildAccountMock().Object,
                                   _fixture.BuildAccountMock().Object,
                                   _fixture.BuildAccountMock().Object,
                                   _fixture.BuildAccountMock().Object,
                                   _fixture.BuildAccountMock().Object,
                                   _fixture.BuildAccountMock().Object
            };

            sut.Add(calculatedAccountCollection.Select(calculatedAccount => _fixture.BuildAccountMock(calculatedAccount: calculatedAccount).Object).ToArray());

            DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
            Sut      result     = await sut.CalculateAsync(statusDate);

            Assert.That(result.CalculateCalledWithCalculatedAccountCollection.All(calculatedAccount => calculatedAccountCollection.Contains(calculatedAccount)), Is.True);
        }
        public async Task CalculateAsync_WhenCalledMultipleTimesWithSameStatusDate_ReturnsSameAccountCollectionBase()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
            IAccountCollectionBase <IAccount, Sut> result = await((IAccountCollectionBase <IAccount, Sut>)await((IAccountCollectionBase <IAccount, Sut>) await sut.CalculateAsync(statusDate)).CalculateAsync(statusDate)).CalculateAsync(statusDate);

            Assert.That(result, Is.SameAs(sut));
        }
        public async Task CalculateAsync_WhenCalledMultipleTimesWithSameStatusDate_AssertAlreadyCalculatedWasCalledTwiceOnSut()
        {
            IAccountCollectionBase <IAccount, Sut> sut = CreateSut();

            DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
            Sut      result     = await((IAccountCollectionBase <IAccount, Sut>)await((IAccountCollectionBase <IAccount, Sut>) await sut.CalculateAsync(statusDate)).CalculateAsync(statusDate)).CalculateAsync(statusDate);

            Assert.That(result.AlreadyCalculatedWasCalledTimes, Is.EqualTo(2));
        }