public async Task ThenMatchingPaymentsShouldBeReturned(
[Frozen] Mock <IPaymentRepository> repository,
[Frozen] Mock <IMapper> autoMapper,
Application.Payments.GetPaymentsQuery.GetPaymentsQueryHandler sut,
GetPaymentsQueryRequest request, PageOfResults <PaymentEntity> paymentEntities, PageOfResults <Payment> expectedResults
)
{
// Arrange
request.Period = new Data.CollectionPeriod
{
Id = "1920-R12",
AcademicYear = 1920,
Period = 12
};
repository.Setup(x => x.GetPayments(request.PageNumber, request.PageSize, request.EmployerAccountId, 1920,
12, request.Ukprn)).ReturnsAsync(paymentEntities);
autoMapper.Setup(x => x.Map <PageOfResults <Payment> >(paymentEntities)).Returns(expectedResults);
// Act
var actualResult = await sut.Handle(request).ConfigureAwait(false);
// Assert
actualResult.IsValid.Should().BeTrue();
actualResult.Result.Should().BeSameAs(expectedResults);
}
public async Task AndThereAreMultiplePagesOfInformationThenTheTransfersAreCreated()
{
var transfersPage1 = new PageOfResults <AccountTransfer>
{
PageNumber = 1,
TotalNumberOfPages = 3,
Items = new[] { new AccountTransfer(), new AccountTransfer(), new AccountTransfer() }
};
var transfersPage2 = new PageOfResults <AccountTransfer>
{
PageNumber = 2,
TotalNumberOfPages = 3,
Items = new[] { new AccountTransfer(), new AccountTransfer() }
};
var transfersPage3 = new PageOfResults <AccountTransfer>
{
PageNumber = 3,
TotalNumberOfPages = 3,
Items = new[] { new AccountTransfer(), new AccountTransfer(), new AccountTransfer() }
};
_providerEventService.Setup(x => x.GetTransfers(_command.PeriodEndId, 1)).ReturnsAsync(transfersPage1);
_providerEventService.Setup(x => x.GetTransfers(_command.PeriodEndId, 2)).ReturnsAsync(transfersPage2);
_providerEventService.Setup(x => x.GetTransfers(_command.PeriodEndId, 3)).ReturnsAsync(transfersPage3);
await _handler.Handle(_command);
_transferRepository.Verify(x => x.SaveTransfers(It.IsAny <IEnumerable <AccountTransfer> >()), Times.Exactly(3));
_transferRepository.Verify(x => x.SaveTransfers(transfersPage1.Items), Times.Once);
_transferRepository.Verify(x => x.SaveTransfers(transfersPage2.Items), Times.Once);
_transferRepository.Verify(x => x.SaveTransfers(transfersPage3.Items), Times.Once);
}
public async Task ThenItShouldReturnTransfersFromRepo()
{
// Arrange
var request = new GetTransfersQueryRequest();
var response = new GetTransfersQueryResponse
{
IsValid = true,
Result = new PageOfResults <AccountTransfer>
{
Items = new AccountTransfer[0]
}
};
var entities = new PageOfResults <TransferEntity>();
_mockTransferRepository.Setup(x => x.GetTransfers(request.PageNumber, request.PageSize, request.SenderAccountId, null, null)).ReturnsAsync(entities);
_mockMapper.Setup(x => x.Map <PageOfResults <AccountTransfer> >(entities)).Returns(response.Result);
// Act
var actualResult = await _getTransfersQueryHandler.Handle(request).ConfigureAwait(false);
// Assert
Assert.IsTrue(actualResult.IsValid);
Assert.AreSame(response.Result, actualResult.Result);
}
private void SetupSubmissionEventsTwoCallsSecondCallReturnsEmptyPage(long sinceEventId)
{
var submissionEventsPageCall1 = new PageOfResults <SubmissionEvent>
{
PageNumber = 1,
TotalNumberOfPages = 2,
Items = new[] { new SubmissionEvent {
Id = sinceEventId + 1, ApprenticeshipId = apprenticeshipId1, EPAOrgId = EpaOrgId1
},
new SubmissionEvent {
Id = sinceEventId + 2, ApprenticeshipId = apprenticeshipId2, EPAOrgId = EpaOrgId2
} }
};
_paymentEvents.Setup(x => x.GetSubmissionEvents(sinceEventId, null, 0L, 1)).ReturnsAsync(submissionEventsPageCall1);
var submissionEventsPageCall2 = new PageOfResults <SubmissionEvent>
{
PageNumber = 1,
TotalNumberOfPages = 0,
Items = new SubmissionEvent[0]
};
_paymentEvents.Setup(x => x.GetSubmissionEvents(sinceEventId + 2, null, 0L, 1)).ReturnsAsync(submissionEventsPageCall2);
}
private List <AccountTransfer> ConfigureTransfers(string periodEnd, int numberOfTransfers, int repeatPages = 1, bool skipPayments = false)
{
var allTransfers = new List <AccountTransfer>();
for (var k = 1; k <= repeatPages; k++)
{
var transfers = new List <AccountTransfer>();
for (var i = 1; i <= numberOfTransfers; i++)
{
transfers.Add(new TransferBuilder().WithPeriod(periodEnd).Build());
}
var transfersResult = new PageOfResults <AccountTransfer>
{
Items = transfers.ToArray(),
PageNumber = k,
TotalNumberOfPages = repeatPages
};
EventsApi.SetupGet($"api/transfers?page={k}&periodId={periodEnd}", transfersResult);
allTransfers.AddRange(transfers);
}
if (!skipPayments)
{
EventsApi.SetupGet($"api/payments?page=1&periodId={periodEnd}&employerAccountId={null}&ukprn={null}", new PageOfResults <Payment> {
PageNumber = 0, TotalNumberOfPages = 0
});
}
return(allTransfers);
}
/// <summary>
/// Projects each element of this PaginatedResults into a new form.
/// </summary>
public PaginatedResults <TTo> Project <TTo>(Func <T, TTo> mapper)
{
if (mapper == null)
{
throw new ArgumentNullException(nameof(mapper));
}
return(new PaginatedResults <TTo>(PageOfResults.Select(mapper).ToArray(), (int)TotalResults, Pagination));
}
public async Task TestMethod1()
{
const string apiBaseUrl = "https://beta-payments.apprenticeships.sfa.bis.gov.uk/";
string clientToken = File.ReadAllText(@"C:\tokens\PaymentsEventsApi_PROD.txt");
//use https://stackoverflow.com/questions/10667012/getting-downloads-folder-in-c?
const string outputPath = @"C:\Users\phil\Downloads\";
var config = new PaymentsEventsApiConfiguration {
ApiBaseUrl = apiBaseUrl, ClientToken = clientToken
};
var client = new PaymentsEventsApiClient(config);
//todo: could provide employeraccountid & prn to reduce volumes!
//var sinceEventId = 1747413 - 1;
//try azure db with and withoug mars
//do web sites write to datalockstatus?
//point to live? nah, db set up pain
//recheck logs for exceptions - search by apprenticeshipid? when error occured?
//could bring in SelectManyAsync
//var datalockEvents = Data.SinceEventIds().SelectMany(async since => await client.GetDataLockEvents(since));
var pageStartIds = Data.SinceEventIds(Data.Ids);
Console.WriteLine("Page start ids:");
Console.WriteLine(string.Join(",", pageStartIds.Select(i => i.ToString())));
List <DataLockEvent> datalockEvents = new List <DataLockEvent>();
foreach (var since in pageStartIds)
{
// var page = await Retries.CallWithRetryAsync<PageOfResults<DataLockEvent>>(c => client.GetDataLockEvents(since));
Console.WriteLine($"Fetching page @ {since}");
var page = await Retries.CallWithRetryAsync(() => client.GetDataLockEvents(since));
datalockEvents = datalockEvents.Concat(page.Items).Where(id => Data.Ids.Contains(id.Id)).ToList();
}
var path = outputPath + "1_payment_event.json";
Console.WriteLine($"Generating {path}");
var newPage = new PageOfResults <DataLockEvent> {
Items = datalockEvents.ToArray(), PageNumber = 1, TotalNumberOfPages = 1
};
var pageJson = JsonConvert.SerializeObject(newPage);
File.WriteAllText(path, pageJson);
}
public void PageOfResultsWithItemsIsValidList()
{
var pg = new PageOfResults <int>(new int[] { 1, 2, 3, 4, 5 }.ToList(), 1, 10);
Assert.AreEqual(5, pg.Count, "count of page items not 5");
Assert.AreEqual(5, pg.PageItemCount, "PageItemCount not 5");
Assert.AreEqual(1, pg.Stats.CurrPageNumber, "stats page is not 1");
Assert.AreEqual(10, pg.Stats.NumPages, "stats page count is not 10");
Assert.IsFalse(pg.Stats.HasPrevPage, "stats has prev is true");
Assert.IsTrue(pg.Stats.HasNextPage, "stats has next is false");
Assert.IsTrue(pg.Stats.HasMultiplePages, "stats has multiple is false");
}
private async Task SaveTransfers(PageOfResults <AccountTransfer> transfers, string periodEndId)
{
try
{
await _transferRepository.SaveTransfers(transfers.Items);
}
catch (Exception ex)
{
_logger.Error(ex, $"Exception thrown saving Transfers for period end {periodEndId}");
throw;
}
}
private async Task SavePayments(PageOfResults <Payment> payments, string periodEndId)
{
try
{
await _paymentRepository.SavePayments(payments.Items);
}
catch (Exception ex)
{
_logger.Error(ex, $"Exception thrown saving payments for period end {periodEndId}");
throw;
}
}
public async Task ThenThePaymentsAreReturned()
{
var period = "ABC123";
var pageNumber = 3;
var expectedResponse = new PageOfResults <Payment>();
EventsApi.Setup(x => x.GetPayments(period, null, pageNumber, null)).ReturnsAsync(expectedResponse);
var response = await Service.GetPayments(period, pageNumber);
response.Should().BeSameAs(expectedResponse);
}
private void SetupSubmissionEventsPageWithSingleEventWithNullApprenticeshipId(long sinceEventId)
{
var submissionEventsPage = new PageOfResults <SubmissionEvent>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new[] { new SubmissionEvent {
Id = sinceEventId + 1, ApprenticeshipId = null, EPAOrgId = EpaOrgId1
} }
};
_paymentEvents.Setup(x => x.GetSubmissionEvents(sinceEventId, null, 0L, 1)).ReturnsAsync(submissionEventsPage);
}
private static PageOfResults <DataLockEvent> CreateV2Event(PageOfResults <DataLockEvent> source)
{
return(new PageOfResults <DataLockEvent>
{
PageNumber = source.PageNumber,
TotalNumberOfPages = source.TotalNumberOfPages,
Items = source.Items.Select(e => new DataLockEvent
{
Id = e.Id,
Status = e.Status,
Errors = new[]
{
new DataLockEventError
{
ErrorCode = e.Errors[0].ErrorCode,
SystemDescription = e.Errors[0].SystemDescription
}
},
Periods = new[]
{
new DataLockEventPeriod
{
ApprenticeshipVersion = e.Periods[0].ApprenticeshipVersion,
Period = new NamedCalendarPeriod
{
Id = e.Periods[0].Period.Id,
Month = e.Periods[0].Period.Month,
Year = e.Periods[0].Period.Year
},
IsPayable = e.Periods[0].IsPayable
}
},
Apprenticeships = new[]
{
new DataLockEventApprenticeship
{
Version = e.Apprenticeships[0].Version,
StartDate = e.Apprenticeships[0].StartDate,
StandardCode = e.Apprenticeships[0].StandardCode,
ProgrammeType = e.Apprenticeships[0].ProgrammeType,
FrameworkCode = e.Apprenticeships[0].FrameworkCode,
PathwayCode = e.Apprenticeships[0].PathwayCode,
NegotiatedPrice = e.Apprenticeships[0].NegotiatedPrice,
EffectiveDate = e.Apprenticeships[0].EffectiveDate
}
}
}).ToArray()
});
}
protected PageOfResults <T> PageResults <T>(List <T> entities, int pageNumber, int pageSize) where T : IAmAPageableEntity
{
var returnValue = new PageOfResults <T>
{
PageNumber = pageNumber,
TotalNumberOfPages = 0,
Items = entities.ToArray(),
};
if (entities.Any())
{
returnValue.TotalNumberOfPages = NumberOfPages(entities.First().TotalCount, pageSize);
}
return(returnValue);
}
private void ConfigureDataLockEvents(int sinceEventId, int numberOfDataLockEvents)
{
var dataLockEvents = new List <DataLockEvent>();
for (var i = 1; i <= numberOfDataLockEvents; i++)
{
dataLockEvents.Add(new DataLockEventBuilder().WithId(i).WithMultipleErrors(2).Build());
}
var dataLockEventsResult = new PageOfResults <DataLockEvent> {
Items = dataLockEvents.ToArray(), PageNumber = 1, TotalNumberOfPages = 1
};
EventsApi.SetupGet($"api/datalock?page=1", dataLockEventsResult);
EventsApi.SetupGet($"api/datalock?page=1&sinceEventId={sinceEventId}", dataLockEventsResult);
}
public async Task AndThereIsASinglePageOfInformationThenTheTransfersAreCreated()
{
var transfers = new PageOfResults <AccountTransfer>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new[] { new AccountTransfer(), new AccountTransfer(), new AccountTransfer() }
};
_providerEventService.Setup(x => x.GetTransfers(_command.PeriodEndId, 1)).ReturnsAsync(transfers);
await _handler.Handle(_command);
_transferRepository.Verify(x => x.SaveTransfers(transfers.Items), Times.Once());
}
public async Task AndThereIsASinglePageOfInformationThenThePaymentsAreCreated()
{
var payments = new PageOfResults <Payment>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new[] { new Payment(), new Payment(), new Payment() }
};
_providerEventService.Setup(x => x.GetPayments(_command.PeriodEndId, 1)).ReturnsAsync(payments);
await _handler.Handle(_command);
_paymentRepository.Verify(x => x.SavePayments(payments.Items), Times.Once());
}
protected PageOfResults <T> AddPagingInformation <T>(List <T> entities, int pageNumber, int pageSize, int count)
{
var returnValue = new PageOfResults <T>
{
PageNumber = pageNumber,
TotalNumberOfPages = 0,
Items = entities.ToArray(),
};
if (entities.Any())
{
returnValue.TotalNumberOfPages = NumberOfPages(count, pageSize);
}
return(returnValue);
}
private void ConfigurePayments(string periodEnd, int numberOfPayments)
{
var payments = new List <Payment>();
for (var i = 1; i <= numberOfPayments; i++)
{
payments.Add(new PaymentBuilder().WithId(periodEnd + i).WithPeriod(periodEnd).Build());
}
var paymentsResult = new PageOfResults <Payment> {
Items = payments.ToArray(), PageNumber = 1, TotalNumberOfPages = 1
};
EventsApi.SetupGet($"api/payments?page=1&periodId={periodEnd}&employerAccountId={null}&ukprn={null}", paymentsResult);
EventsApi.SetupGet($"api/transfers?page=1&periodId={periodEnd}", new PageOfResults <Payment> {
PageNumber = 0, TotalNumberOfPages = 0
});
}
public async Task AndSubmissionEventContainsUnknownApprenticeshipThenValidApprenticeshipsAreStillUpdatedAndInvalidApprenticeshipIsLogged()
{
const long sinceEventId = 0L;
SetupOrganisationSummaries();
var submissionEventsPage = new PageOfResults <SubmissionEvent>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new[]
{
new SubmissionEvent {
Id = sinceEventId + 1, ApprenticeshipId = apprenticeshipId1, EPAOrgId = EpaOrgId1
},
new SubmissionEvent {
Id = sinceEventId + 2, ApprenticeshipId = unknownApprenticeshipId, EPAOrgId = EpaOrgId1
},
new SubmissionEvent {
Id = sinceEventId + 3, ApprenticeshipId = apprenticeshipId2, EPAOrgId = EpaOrgId2
}
}
};
_paymentEvents.Setup(x => x.GetSubmissionEvents(sinceEventId, null, 0L, 1)).ReturnsAsync(submissionEventsPage);
_apprenticeshipRepository.Setup(x => x.UpdateApprenticeshipEpa(unknownApprenticeshipId, EpaOrgId1))
.Throws <ArgumentOutOfRangeException>();
// act
await _addEpaToApprenticeships.Update();
// assert
// check valid apprenticeships before and after unknown apprenticeship are updated
_apprenticeshipRepository.Verify(x => x.UpdateApprenticeshipEpa(apprenticeshipId1, EpaOrgId1), Times.Once());
_apprenticeshipRepository.Verify(x => x.UpdateApprenticeshipEpa(apprenticeshipId2, EpaOrgId2), Times.Once());
_log.Verify(x => x.Error(It.IsAny <ArgumentOutOfRangeException>(), It.Is <string>(
message => CheckUnknownApprenticeshipLogMessage(message))), Times.Once);
_jobProgressRepository.Verify(x => x.Set_AddEpaToApprenticeships_LastSubmissionEventId(sinceEventId + 3), Times.Once);
}
internal static PageOfResults <Provider.Events.Api.Types.Payment> GetPayment()
{
var por = new PageOfResults <Provider.Events.Api.Types.Payment>();
por.PageNumber = 1;
por.TotalNumberOfPages = 1;
por.Items = new List <Provider.Events.Api.Types.Payment>
{
new Provider.Events.Api.Types.Payment
{
Id = "f97840b3-d3bf-429c-bc3c-8a877f4f26f8",
ApprenticeshipId = 11002,
EmployerAccountId = "MJK9XV",
CollectionPeriod = new NamedCalendarPeriod
{
Id = "1617-r10",
Year = 2017,
Month = 5
},
EarningDetails = new List <Earning>
{
new Earning
{
ActualEndDate = DateTime.Parse("2017-03-01"),
CompletionAmount = 5000,
RequiredPaymentId = Guid.Parse("f97840b3-d3bf-429c-bc3c-8a877f4f26f8"),
CompletionStatus = 1,
MonthlyInstallment = 300,
TotalInstallments = 24,
StartDate = DateTime.Parse("2018-01-01"),
PlannedEndDate = DateTime.Parse("2020-01-01"),
EndpointAssessorId = "EOId-1"
}
},
ContractType = ContractType.ContractWithSfa,
FundingSource = Provider.Events.Api.Types.FundingSource.Levy,
TransactionType = TransactionType.Balancing
}
}
.ToArray();
return(por);
}
public void AndSavingATransferFailsThenTheExceptionIsLogged()
{
var expectedException = new Exception();
var failingTransfer = new AccountTransfer {
TransferId = 1
};
var transfers = new PageOfResults <AccountTransfer>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new[] { new AccountTransfer(), failingTransfer, new AccountTransfer() }
};
_providerEventService.Setup(x => x.GetTransfers(_command.PeriodEndId, 1)).ReturnsAsync(transfers);
_transferRepository.Setup(x => x.SaveTransfers(transfers.Items)).Throws(expectedException);
Assert.ThrowsAsync <Exception>(() => _handler.Handle(_command));
_logger.Verify(x => x.Error(expectedException, $"Exception thrown saving Transfers for period end {_command.PeriodEndId}"));
}
public async Task AndSavingAPaymentFailsThenTheExceptionIsLogged()
{
var expectedException = new Exception();
var failingPayment = new Payment {
Id = "PayID"
};
var payments = new PageOfResults <Payment>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new[] { new Payment(), failingPayment, new Payment() }
};
_providerEventService.Setup(x => x.GetPayments(_command.PeriodEndId, 1)).ReturnsAsync(payments);
_paymentRepository.Setup(x => x.SavePayments(payments.Items)).Throws(expectedException);
Assert.ThrowsAsync <Exception>(() => _handler.Handle(_command));
_logger.Verify(x => x.Error(expectedException, $"Exception thrown saving payments for period end {_command.PeriodEndId}"));
}
private static string SendPayments(Faker <Payment> paymentFaker, int count = 10)
{
var payments = new List <Payment>();
for (var i = 0; i < count; i++)
{
var payment = paymentFaker.Generate();
payments.Add(payment);
}
var page = new PageOfResults <Payment>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = payments.ToArray()
};
return(JsonConvert.SerializeObject(page));
}
public void Arrange()
{
_eventService = new Mock <IProviderEventService>();
_logger = new Mock <ILog>();
var dataLock = new DataLockEvent {
Id = 1
};
var _expectedDataLocks = new PageOfResults <DataLockEvent>
{
PageNumber = 1,
TotalNumberOfPages = 1,
Items = new DataLockEvent[1] {
dataLock
}
};
_eventService.Setup(x => x.GetUnprocessedDataLocks()).ReturnsAsync(_expectedDataLocks);
_collector = new DataLockEventCollector(_eventService.Object, _logger.Object, new DataConfiguration {
DataLocksEnabled = true
});
}
public void PageOfResultsWithNullItemsIsEmptyList()
{
var pg = new PageOfResults <int>(null, 1, 10);
Assert.AreEqual(0, pg.Count);
}
public void PageOfResultsWithPageNumMoreThanNumPagesRaisesException()
{
var pg = new PageOfResults <int>(null, 11, 10);
}
public void PageOfResultsWithZeroNumPagesRaisesException()
{
var pg = new PageOfResults <int>(null, 1, 0);
}
public void PageOfResultsWithNegativeNumPagesRaisesException()
{
var pg = new PageOfResults <int>(null, 1, -1);
}
public void PageOfResultsWithZeroPageNumRaisesException()
{
var pg = new PageOfResults <int>(null, 0, 10);
}
