public async Task When_CreatingCertificateRecord_CallsInternalApi_Then_ReturnCertificateWithResponseCode200(
CreateCertificateRequest request,
IEnumerable <CreateCertificateResponse> response)
{
//Arrange
CreateBatchCertificateRequest transformedRequest = null;
var requests = new List <CreateCertificateRequest> {
request
};
_mockApiClient.Setup(s => s.CreateCertificates(It.IsAny <IEnumerable <CreateBatchCertificateRequest> >()))
.Callback <IEnumerable <CreateBatchCertificateRequest> >((input) => transformedRequest = input.First())
.ReturnsAsync(response);
//Act
var result = await _controller.CreateCertificates(requests) as ObjectResult;
//Assert
result.StatusCode.Value.Should().Be((int)HttpStatusCode.OK);
transformedRequest.Should().NotBeNull();
transformedRequest.Should().BeEquivalentTo(new
{
UkPrn = _headerInfo.Object.Ukprn,
request.RequestId,
CertificateData = new
{
request.Standard,
request.Learner,
request.LearningDetails,
request.PostalContact
}
});
result.Value.Should().Be(response);
}
public async Task WhenCallingCreateCertificate_ExistingEPARecord_VersionIsNotSupplied_GetStandardVersionRequestSent_AndFieldsPopulated(
Standard standard,
Certificate certificate,
CertificateData certData,
CreateBatchCertificateRequest request)
{
//Arrange
certificate.CertificateData = JsonConvert.SerializeObject(certData);
request.StandardCode = 0;
request.CertificateData.Version = null;
_mockMediator.Setup(s => s.Send(It.IsAny <GetCalculatedStandardVersionForApprenticeshipRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(standard);
_mockMediator.Setup(t => t.Send(It.Is <GetCertificateForUlnRequest>(s => s.Uln == request.Uln && s.StandardCode == standard.LarsCode), new System.Threading.CancellationToken())).ReturnsAsync(certificate);
_mockCreateBatchValidator.Setup(s => s.ValidateAsync(request, new System.Threading.CancellationToken())).ReturnsAsync(new ValidationResult());
//Act
var controllerResult = await _certificateBatchController.Create(new List <CreateBatchCertificateRequest> {
request
}) as ObjectResult;
//Assert
_mockMediator.Verify(a => a.Send(It.Is <GetCalculatedStandardVersionForApprenticeshipRequest>(b => b.StandardId == request.StandardReference && b.Uln == request.Uln), new System.Threading.CancellationToken()), Times.Once);
request.StandardCode.Should().Be(standard.LarsCode);
request.StandardReference.Should().NotBe(standard.IfateReferenceNumber);
// Making sure the EPA record populates the data on the request
request.CertificateData.Version.Should().Be(certData.Version);
request.StandardUId.Should().Be(certificate.StandardUId);
}
public async Task WhenCallingCreateCertificate_ValidationSuccessful_ReturnsCertificateDetails(
Standard standard,
Certificate certificate,
CreateBatchCertificateRequest request)
{
//Arrange
var validationResult = new ValidationResult();
_mockMediator.Setup(s => s.Send(It.IsAny <GetStandardVersionRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(standard);
_mockMediator.Setup(s => s.Send(It.IsAny <CreateBatchCertificateRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(certificate);
_mockCreateBatchValidator.Setup(s => s.ValidateAsync(request, new System.Threading.CancellationToken())).ReturnsAsync(validationResult);
//Act
var controllerResult = await _certificateBatchController.Create(new List <CreateBatchCertificateRequest> {
request
}) as ObjectResult;
//Assert
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as IEnumerable <BatchCertificateResponse>;
var result = model.First();
result.RequestId.Should().Be(request.RequestId);
result.StandardCode.Should().Be(request.StandardCode);
result.StandardReference.Should().Be(request.StandardReference);
result.Uln.Should().Be(request.Uln);
result.FamilyName.Should().Be(request.FamilyName);
result.Certificate.Should().BeEquivalentTo(certificate);
result.ValidationErrors.Should().BeEmpty();
}
public async Task Arrange()
{
CreateBatchCertificateRequest request = Builder <CreateBatchCertificateRequest> .CreateNew()
.With(i => i.Uln = 5555555555)
.With(i => i.StandardCode = 1)
.With(i => i.StandardReference = null)
.With(i => i.UkPrn = 12345678)
.With(i => i.FamilyName = "Test")
.With(i => i.CertificateReference = null)
.With(i => i.CertificateData = Builder <CertificateData> .CreateNew()
.With(cd => cd.ContactPostCode = "AA11AA")
.With(cd => cd.AchievementDate = DateTime.UtcNow)
.With(cd => cd.OverallGrade = CertificateGrade.Pass)
.With(cd => cd.CourseOption = null)
.Build())
.Build();
_validationResult = await Validator.ValidateAsync(request);
}
private CreateBatchCertificateRequest CreateInvalidRequest()
{
CreateBatchCertificateRequest request = Builder <CreateBatchCertificateRequest> .CreateNew()
.With(i => i.Uln = 1234567891)
.With(i => i.StandardCode = 1)
.With(i => i.StandardReference = null)
.With(i => i.UkPrn = 12345678)
.With(i => i.FamilyName = "Test")
.With(i => i.CertificateReference = null)
.With(i => i.CertificateData = Builder <CertificateData> .CreateNew()
.With(cd => cd.ContactPostCode = "AA11AA")
.With(cd => cd.AchievementDate = DateTime.UtcNow)
.With(cd => cd.OverallGrade = CertificateGrade.Pass)
.With(cd => cd.CourseOption = null)
.Build())
.Build();
return(request);
}
public void SetUp()
{
_certificateRepository = new Mock <ICertificateRepository>();
_learnerRepository = new Mock <ILearnerRepository>();
_organisationQueryRepository = new Mock <IOrganisationQueryRepository>();
_contactQueryRepository = new Mock <IContactQueryRepository>();
_logger = new Mock <ILogger <CreateBatchCertificateHandler> >();
_standardService = new Mock <IStandardService>();
_mockProvidersRepository = new Mock <IProvidersRepository>();
_learnerRepository.Setup(m => m.Get(uln, stdCode)).ReturnsAsync(new Domain.Entities.Learner()
{
UkPrn = learnerUkprn
});
_organisationQueryRepository.Setup(m => m.GetByUkPrn(ukPrn)).ReturnsAsync(new Organisation()
{
});
_standardService.Setup(m => m.GetStandardVersionById(stdUId, null)).ReturnsAsync(new Standard()
{
});
_standardService.Setup(m => m.GetStandardOptionsByStandardId(stdUId)).ReturnsAsync(new StandardOptions());
_mockProvidersRepository.Setup(m => m.GetProvider(learnerUkprn)).ReturnsAsync(new Provider()
{
Ukprn = ukPrn,
Name = "PROVIDER"
});
_request = new CreateBatchCertificateRequest()
{
StandardCode = stdCode,
StandardUId = stdUId,
Uln = uln,
UkPrn = ukPrn,
CertificateData = new Domain.JsonData.CertificateData()
};
_handler = new CreateBatchCertificateHandler(_certificateRepository.Object, _learnerRepository.Object, _organisationQueryRepository.Object,
_contactQueryRepository.Object, _logger.Object, _standardService.Object, _mockProvidersRepository.Object);
}
public async Task Arrange()
{
CreateBatchCertificateRequest request = Builder <CreateBatchCertificateRequest> .CreateNew()
.With(i => i.Uln = 9999999999)
.With(i => i.StandardCode = 99)
.With(i => i.StandardReference = null)
.With(i => i.UkPrn = 99999999)
.With(i => i.FamilyName = "Test")
.With(i => i.CertificateReference = null)
.With(i => i.CertificateData = Builder <CertificateData> .CreateNew()
.With(cd => cd.ContactPostCode = "AA11AA")
.With(cd => cd.AchievementDate = DateTime.UtcNow)
.With(cd => cd.OverallGrade = CertificateGrade.Pass)
.With(cd => cd.CourseOption = null) // should not cause validation error because Learner course option is "English"
.With(cd => cd.Version = "1.0")
.Build())
.Build();
_validationResult = await Validator.ValidateAsync(request);
}
public async Task WhenCallingCreateCertificate_VersionIsSupplied_GetStandardVersionRequestSent_AndFieldsPopulated(
Standard standard,
CreateBatchCertificateRequest request)
{
//Arrange
request.CertificateData.Version = "1.0";
request.StandardCode = 0;
_mockMediator.Setup(s => s.Send(It.IsAny <GetStandardVersionRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(standard);
_mockCreateBatchValidator.Setup(s => s.ValidateAsync(request, new System.Threading.CancellationToken())).ReturnsAsync(new ValidationResult());
//Act
var controllerResult = await _certificateBatchController.Create(new List <CreateBatchCertificateRequest> {
request
}) as ObjectResult;
//Assert
_mockMediator.Verify(a => a.Send(It.Is <GetStandardVersionRequest>(b => b.StandardId == request.StandardReference && b.Version == request.CertificateData.Version), new System.Threading.CancellationToken()), Times.Once);
request.StandardCode.Should().Be(standard.LarsCode);
request.StandardReference.Should().NotBe(standard.IfateReferenceNumber);
request.StandardUId.Should().Be(standard.StandardUId);
// Making sure the standard doesn't overwrite the version in populate fields.
// As it is supplied
request.CertificateData.Version.Should().NotBe(standard.Version);
}
public async Task WhenCallingCreateCertificate_VersionIsNotSupplied_NoEPARecord_CalculateStandardVersionRequestSent_AndFieldsPopulated(
Standard standard,
CreateBatchCertificateRequest request)
{
//Arrange
request.CertificateData.Version = null;
request.StandardReference = null;
_mockMediator.Setup(s => s.Send(It.IsAny <GetCalculatedStandardVersionForApprenticeshipRequest>(), new System.Threading.CancellationToken())).ReturnsAsync(standard);
_mockMediator.Setup(t => t.Send(It.Is <GetCertificateForUlnRequest>(s => s.Uln == request.Uln && s.StandardCode == standard.LarsCode), new System.Threading.CancellationToken())).ReturnsAsync((Certificate)null);
_mockCreateBatchValidator.Setup(s => s.ValidateAsync(request, new System.Threading.CancellationToken())).ReturnsAsync(new ValidationResult());
//Act
var controllerResult = await _certificateBatchController.Create(new List <CreateBatchCertificateRequest> {
request
}) as ObjectResult;
//Assert
_mockMediator.Verify(a => a.Send(It.Is <GetCalculatedStandardVersionForApprenticeshipRequest>(b => b.StandardId == request.StandardCode.ToString() && b.Uln == request.Uln), new System.Threading.CancellationToken()), Times.Once);
request.CertificateData.Version.Should().Be(standard.Version);
request.StandardUId.Should().Be(standard.StandardUId);
request.StandardReference.Should().Be(standard.IfateReferenceNumber);
// Existing field shouldn't be overwritten.
request.StandardCode.Should().NotBe(standard.LarsCode);
}
