public async Task Then_first_id_is_returned_when_has_submitted_applications()
{
// Arrange
var accountId = _fixture.Create <long>();
var accountLegalEntityId = _fixture.Create <long>();
var account = _fixture.Build <Models.Account>().With(x => x.Id, accountId).With(x => x.AccountLegalEntityId, accountLegalEntityId).Create();
var allApplications = _fixture.CreateMany <Models.IncentiveApplication>(5).ToArray();
foreach (var application in allApplications)
{
application.AccountId = accountId;
application.AccountLegalEntityId = accountLegalEntityId;
application.Status = IncentiveApplicationStatus.Submitted;
}
_context.Accounts.Add(account);
_context.Applications.AddRange(allApplications);
var expectedId = allApplications.OrderBy(x => x.DateSubmitted).First().Id;
_context.SaveChanges();
// Act
var result = await _sut.GetFirstSubmittedApplicationId(accountLegalEntityId);
// Assert
result.Should().Be(expectedId);
}
public async Task Then_data_is_fetched_from_database_for_an_account_with_a_single_legal_entity(string vrfCaseStatus)
{
// Arrange
var allAccounts = _fixture.CreateMany <Models.Account>(10).ToArray();
const long accountId = -1;
allAccounts[0].Id = accountId;
allAccounts[0].VrfCaseStatus = vrfCaseStatus;
_context.Accounts.AddRange(allAccounts);
var allApplications = _fixture.CreateMany <Models.IncentiveApplication>(10).ToArray();
for (var i = 0; i < 10; i++)
{
allApplications[i].AccountId = allAccounts[i].Id;
allApplications[i].AccountLegalEntityId = allAccounts[i].AccountLegalEntityId;
}
_context.Applications.AddRange(allApplications);
_context.SaveChanges();
// Act
var actual = (await _sut.GetByVrfCaseStatus(vrfCaseStatus)).ToArray();
//Assert
actual.All(x => x.AccountId == accountId).Should().BeTrue();
actual.Length.Should().Be(1);
actual[0].LegalEntities.Count(x => x.AccountLegalEntityId == allAccounts[0].AccountLegalEntityId).Should().Be(1);
}
private void SetupPendingPayments()
{
_pendingPayment1 = _fixture.Build <PendingPayment>().Create();
var pendingPayments = new List <PendingPayment>
{
_pendingPayment1
};
_context.PendingPayments.AddRange(pendingPayments);
_context.SaveChanges();
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var pendingPayment = _fixture.Create <PendingPayment>();
_context.PendingPayments.Add(pendingPayment);
_context.SaveChanges();
// Act
var actual = await _sut.Get(x => x.Id == pendingPayment.Id);
//Assert
actual.Should().BeEquivalentTo(pendingPayment, opts => opts.ExcludingMissingMembers());
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var accounts = _fixture.CreateMany <Models.Account>(3);
_context.Accounts.AddRange(accounts);
_context.SaveChanges();
// Act
var actual = await _sut.Get(x => x.LegalEntityId == accounts.First().LegalEntityId);
//Assert
actual.Should().BeEquivalentTo(accounts.First(), opts => opts.ExcludingMissingMembers());
}
public async Task Then_data_is_fetched_from_database()
{
var allApprenticeships = _fixture.Build <Models.IncentiveApplicationApprenticeship>().CreateMany(10).ToArray();
var apprenticeshipId = Guid.NewGuid();
allApprenticeships[1].Id = apprenticeshipId;
_context.ApplicationApprenticeships.AddRange(allApprenticeships);
_context.SaveChanges();
// Act
var actual = await _sut.Get(x => x.Id == apprenticeshipId);
//Assert
actual.Should().BeEquivalentTo(allApprenticeships[1], opts => opts.ExcludingMissingMembers());
}
public async Task Then_the_account_is_updated_if_it_already_exists()
{
// Arrange
var testAccount = _fixture.Create <Models.Account>();
_dbContext.Add(_fixture.Create <Models.Account>());
_dbContext.Add(testAccount);
_dbContext.Add(_fixture.Create <Models.Account>());
_dbContext.SaveChanges();
var newName = testAccount.LegalEntityName + "changed";
var newHasSignedTerms = !testAccount.HasSignedIncentivesTerms;
var newSignedVersion = testAccount.SignedAgreementVersion + 1;
var legalEntities = new List <LegalEntityModel>
{
new LegalEntityModel
{
Id = testAccount.LegalEntityId,
AccountLegalEntityId = testAccount.AccountLegalEntityId,
Name = newName,
HasSignedAgreementTerms = newHasSignedTerms,
SignedAgreementVersion = newSignedVersion
}
};
var accountModel = new AccountModel {
Id = testAccount.Id, LegalEntityModels = legalEntities
};
// Act
await _sut.Update(accountModel);
await _dbContext.SaveChangesAsync();
// Assert
var addedAccount = _dbContext.Accounts.Single(a => a.Id == testAccount.Id && a.AccountLegalEntityId == testAccount.AccountLegalEntityId);
addedAccount.LegalEntityId.Should().Be(testAccount.LegalEntityId);
addedAccount.LegalEntityName.Should().Be(newName);
addedAccount.HasSignedIncentivesTerms.Should().Be(newHasSignedTerms);
addedAccount.SignedAgreementVersion.Should().Be(newSignedVersion);
addedAccount.VrfCaseId.Should().Be(testAccount.VrfCaseId);
addedAccount.VrfCaseStatus.Should().Be(testAccount.VrfCaseStatus);
addedAccount.VrfVendorId.Should().Be(testAccount.VrfVendorId);
addedAccount.VrfCaseStatusLastUpdatedDateTime.Should().Be(testAccount.VrfCaseStatusLastUpdatedDateTime);
addedAccount.HashedLegalEntityId.Should().Be(testAccount.HashedLegalEntityId);
}
public async Task Then_the_expected_account_is_returned_if_it_exists()
{
// Arrange
var testAccount = _fixture.Create <Models.Account>();
_dbContext.Add(testAccount);
_dbContext.SaveChanges();
// Act
var account = await _sut.Find(testAccount.Id);
// Assert
account.Should().NotBeNull();
account.Id.Should().Be(testAccount.Id);
var legalEntity = account.LegalEntityModels.Single();
legalEntity.Id.Should().Be(testAccount.LegalEntityId);
legalEntity.Name.Should().Be(testAccount.LegalEntityName);
legalEntity.AccountLegalEntityId.Should().Be(testAccount.AccountLegalEntityId);
legalEntity.HashedLegalEntityId.Should().Be(testAccount.HashedLegalEntityId);
legalEntity.VrfCaseStatusLastUpdatedDateTime.Should().Be(testAccount.VrfCaseStatusLastUpdatedDateTime);
legalEntity.VrfCaseStatus.Should().Be(testAccount.VrfCaseStatus);
legalEntity.VrfVendorId.Should().Be(testAccount.VrfVendorId);
legalEntity.VrfCaseId.Should().Be(testAccount.VrfCaseId);
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var account = _fixture.Create <Models.Account>();
var allApplications = _fixture.Build <Models.IncentiveApplication>().With(x => x.AccountLegalEntityId, account.AccountLegalEntityId).CreateMany <Models.IncentiveApplication>(10).ToArray();
const long accountId = -1;
allApplications[0].AccountId = accountId;
allApplications[3].AccountId = accountId;
_context.Accounts.Add(account);
_context.Applications.AddRange(allApplications);
_context.SaveChanges();
// Act
var actual = (await _sut.GetList(x => x.AccountId == accountId)).ToArray();
//Assert
actual.All(x => x.AccountId == accountId).Should().BeTrue();
actual.Should().BeEquivalentTo(new[] { allApplications[0], allApplications[3] }, opts => opts.ExcludingMissingMembers());
}
public async Task Then_all_apprenticeship_incentives_are_returned()
{
var apprenticeshipIncentives =
_fixture.CreateMany <ApprenticeshipIncentives.Models.ApprenticeshipIncentive>().ToList();
foreach (var incentive in apprenticeshipIncentives)
{
incentive.Status = IncentiveStatus.Active;
}
_context.ApprenticeshipIncentives.AddRange(apprenticeshipIncentives);
_context.SaveChanges();
var actual = await _sut.GetList();
actual.Count.Should().Be(apprenticeshipIncentives.Count);
actual.Should().Contain(x => x.Id == apprenticeshipIncentives[0].Id);
actual.Should().Contain(x => x.ApprenticeshipId == apprenticeshipIncentives[0].ApprenticeshipId);
actual.Should().Contain(x => x.ULN == apprenticeshipIncentives[0].ULN);
actual.Should().Contain(x => x.UKPRN == apprenticeshipIncentives[0].UKPRN);
}
public async Task Then_legal_entities_with_unsent_clawbacks_in_the_current_period_are_returned_when_isSent_if_false()
{
short collectionPeriodYear = 2020;
byte collectionPeriod = 5;
var clawbackPayments = new List <ClawbackPayment>
{
_fixture.Build <ClawbackPayment>().With(x => x.CollectionPeriodYear, collectionPeriodYear).With(x => x.CollectionPeriod, collectionPeriod).With(x => x.DateClawbackSent, (DateTime?)null).Create(),
_fixture.Build <ClawbackPayment>().With(x => x.CollectionPeriodYear, collectionPeriodYear).With(x => x.CollectionPeriod, collectionPeriod).With(x => x.DateClawbackSent, (DateTime?)null).Create(),
_fixture.Build <ClawbackPayment>().With(x => x.CollectionPeriodYear, collectionPeriodYear).With(x => x.CollectionPeriod, collectionPeriod).With(x => x.DateClawbackSent).Create(),
_fixture.Build <ClawbackPayment>().With(x => x.CollectionPeriodYear, collectionPeriodYear).With(x => x.CollectionPeriod, (byte)(collectionPeriod + 1)).With(x => x.DateClawbackSent, (DateTime?)null).Create(),
};
_context.ClawbackPayments.AddRange(clawbackPayments);
_context.SaveChanges();
var actual = await _sut.GetClawbackLegalEntities(collectionPeriodYear, collectionPeriod, false);
actual.Count.Should().Be(2);
actual.Should().Contain(x => x.AccountLegalEntityId == clawbackPayments[0].AccountLegalEntityId &&
x.AccountId == clawbackPayments[0].AccountId &&
!x.IsSent);
actual.Should().Contain(x => x.AccountLegalEntityId == clawbackPayments[1].AccountLegalEntityId &&
x.AccountId == clawbackPayments[1].AccountId &&
!x.IsSent);
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var account = _fixture.Create <Models.Account>();
var allApplications = _fixture.Build <Models.IncentiveApplication>().With(x => x.AccountLegalEntityId, account.AccountLegalEntityId).CreateMany <Models.IncentiveApplication>(10).ToArray();
var applicationId = Guid.NewGuid();
allApplications[1].Id = applicationId;
_context.Accounts.Add(account);
_context.Applications.AddRange(allApplications);
_context.SaveChanges();
// Act
var actual = await _sut.Get(x => x.ApplicationId == applicationId);
//Assert
actual.ApplicationId.Should().Be(applicationId);
actual.ApplicationStatus.Should().Be(allApplications[1].Status);
actual.LegalEntityId.Should().Be(account.LegalEntityId);
actual.VrfCaseId.Should().Be(account.VrfCaseId);
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var expectedAccounts = _fixture.Build <Models.Account>().With(x => x.VrfCaseStatus, "To Process").CreateMany(5);
var notExpectedAccounts = _fixture.Build <Models.Account>().With(x => x.VrfCaseId, (string)null).CreateMany(5);
_context.Accounts.AddRange(expectedAccounts);
_context.Accounts.AddRange(notExpectedAccounts);
_context.SaveChanges();
// Act
var actual = await _sut.GetList(x => x.VrfCaseStatus != "Case Request completed" && x.VrfCaseId != null);
//Assert
actual.Should().BeEquivalentTo(expectedAccounts, opts => opts.ExcludingMissingMembers());
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var accountLegalEntityId = _fixture.Create <long>();
var allPendingPayments = _fixture.CreateMany <PendingPayment>(10).ToArray();
allPendingPayments[0].AccountLegalEntityId = accountLegalEntityId;
allPendingPayments[3].AccountLegalEntityId = accountLegalEntityId;
_context.PendingPayments.AddRange(allPendingPayments);
_context.SaveChanges();
// Act
var actual = (await _sut.GetList(x => x.AccountLegalEntityId == accountLegalEntityId)).ToArray();
//Assert
actual.All(x => x.AccountLegalEntityId == accountLegalEntityId).Should().BeTrue();
actual.Should().BeEquivalentTo(new[] { allPendingPayments[0], allPendingPayments[3] }, opts => opts.ExcludingMissingMembers());
}
public async Task Then_the_expected_account_is_returned_if_it_exists()
{
// Arrange
const string legalEntityId = "XYZ123__";
var testAccounts = _fixture.CreateMany <Models.Account>(4).ToList();
testAccounts.First().HashedLegalEntityId = legalEntityId;
testAccounts.Last().HashedLegalEntityId = legalEntityId;
_dbContext.AddRange(testAccounts);
_dbContext.SaveChanges();
// Act
var accounts = await _sut.GetByHashedLegalEntityId(legalEntityId);
// Assert
accounts.Should().BeEquivalentTo(testAccounts.Where(x => x.HashedLegalEntityId == legalEntityId),
opt => opt.ExcludingMissingMembers());
}
public async Task Then_data_is_fetched_from_database()
{
// Arrange
var allAccounts = _fixture.CreateMany <Models.Account>(10).ToArray();
const long accountId = -1;
allAccounts[0].Id = accountId;
allAccounts[1].Id = accountId;
_context.Accounts.AddRange(allAccounts);
_context.SaveChanges();
// Act
var actual = (await _sut.GetList(x => x.AccountId == accountId)).ToArray();
//Assert
actual.All(x => x.AccountId == accountId).Should().BeTrue();
actual.Should().BeEquivalentTo(new [] { allAccounts[0], allAccounts[1] },
opts => opts.ExcludingMissingMembers());
}
public async Task Then_legal_entities_with_pending_payments_in_the_current_period_are_returned()
{
short collectionPeriodYear = 2020;
byte collectionPeriod = 5;
var pendingPayments = new List <PendingPayment>
{
_fixture.Build <PendingPayment>().With(x => x.PaymentYear, collectionPeriodYear).With(x => x.PeriodNumber, collectionPeriod).With(x => x.PaymentMadeDate, (DateTime?)null).Create(),
_fixture.Build <PendingPayment>().With(x => x.PaymentYear, collectionPeriodYear).With(x => x.PeriodNumber, collectionPeriod).With(x => x.PaymentMadeDate, (DateTime?)null).Create(),
_fixture.Build <PendingPayment>().With(x => x.PaymentYear, collectionPeriodYear).With(x => x.PeriodNumber, (byte)(collectionPeriod + 1)).With(x => x.PaymentMadeDate, (DateTime?)null).Create(),
};
_context.PendingPayments.AddRange(pendingPayments);
_context.SaveChanges();
var actual = await _sut.GetPayableLegalEntities(collectionPeriodYear, collectionPeriod);
actual.Count.Should().Be(2);
actual.Should().Contain(x => x.AccountLegalEntityId == pendingPayments[0].AccountLegalEntityId);
actual.Should().Contain(x => x.AccountLegalEntityId == pendingPayments[1].AccountLegalEntityId);
}