public void Then_If_Error_For_Verify_An_Exception_Is_Thrown(
string errorContent,
StopEmployerDemandCommand command,
GetEmployerDemandResponse getDemandResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > mockApiClient,
[Frozen] Mock <INotificationService> mockNotificationService,
StopEmployerDemandCommandHandler handler)
{
//Arrange
getDemandResponse.Stopped = false;
var stopResponse = new ApiResponse <string>(null, HttpStatusCode.InternalServerError, errorContent);
mockApiClient
.Setup(client => client.PatchWithResponseCode(
It.Is <PatchCourseDemandRequest>(request => request.PatchUrl.Contains(command.EmployerDemandId.ToString()))))
.ReturnsAsync(stopResponse);
mockApiClient
.Setup(client => client.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(request => request.GetUrl.Contains($"demand/{command.EmployerDemandId}"))))
.ReturnsAsync(getDemandResponse);
//Act
Func <Task> act = async() => await handler.Handle(command, CancellationToken.None);
//Assert
act.Should().Throw <HttpRequestContentException>().WithMessage($"Response status code does not indicate success: {(int)HttpStatusCode.InternalServerError} ({HttpStatusCode.InternalServerError})")
.Which.ErrorContent.Should().Be(errorContent);
mockNotificationService.Verify(service => service.Send(It.IsAny <SendEmailCommand>()),
Times.Never);
}
public async Task Then_The_Email_Is_Not_Sent_If_Already_Verified_On_Get_Demand(
VerifyEmployerDemandCommand command,
PostEmployerCourseDemand verifyEmailResponse,
GetEmployerDemandResponse getDemandResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > apiClient,
[Frozen] Mock <INotificationService> notificationService,
VerifyEmployerDemandCommandHandler handler)
{
//Arrange
getDemandResponse.EmailVerified = true;
apiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{command.Id}"))))
.ReturnsAsync(getDemandResponse);
//Act
var actual = await handler.Handle(command, CancellationToken.None);
//Assert
apiClient.Verify(client => client.PatchWithResponseCode(
It.IsAny <PatchCourseDemandRequest>()), Times.Never);
notificationService.Verify(service => service.Send(It.IsAny <SendEmailCommand>()),
Times.Never);
actual.EmployerDemand.Should().BeEquivalentTo(getDemandResponse);
}
public void Then_If_Error_For_Verify_An_Exception_Is_Thrown(
string errorContent,
GetEmployerDemandResponse getDemandResponse,
VerifyEmployerDemandCommand command,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > apiClient,
[Frozen] Mock <INotificationService> notificationService,
VerifyEmployerDemandCommandHandler handler)
{
//Arrange
getDemandResponse.EmailVerified = false;
apiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{command.Id}"))))
.ReturnsAsync(getDemandResponse);
var apiResponse = new ApiResponse <string>("patchResponse", HttpStatusCode.BadRequest, errorContent);
apiClient.Setup(
x => x.PatchWithResponseCode(It.IsAny <PatchCourseDemandRequest>())).ReturnsAsync(apiResponse);
//Act
Func <Task> act = async() => await handler.Handle(command, CancellationToken.None);
//Assert
act.Should().Throw <HttpRequestContentException>().WithMessage($"Response status code does not indicate success: {(int)HttpStatusCode.BadRequest} ({HttpStatusCode.BadRequest})")
.Which.ErrorContent.Should().Be(errorContent);
notificationService.Verify(service => service.Send(It.IsAny <SendEmailCommand>()),
Times.Never);
}
public async Task Then_The_Demand_Data_Is_Returned_From_The_Api(
GetRestartEmployerDemandQuery query,
GetEmployerDemandResponse getDemandResponse,
GetStandardsListItem getStandardResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > demandApiClient,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > coursesApiClient,
GetRestartEmployerDemandQueryHandler handler)
{
//Arrange
demandApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandByExpiredDemandRequest>(c => c.GetUrl.Contains($"demand?expiredCourseDemandId={query.Id}"))))
.ReturnsAsync((GetEmployerDemandResponse)null);
demandApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{query.Id}"))))
.ReturnsAsync(getDemandResponse);
coursesApiClient.Setup(x =>
x.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(c => c.GetUrl.Contains($"api/courses/standards/{getDemandResponse.Course.Id}"))))
.ReturnsAsync(getStandardResponse);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.EmployerDemand.Should().BeEquivalentTo(getDemandResponse);
actual.RestartDemandExists.Should().BeFalse();
actual.LastStartDate.Should().Be(getStandardResponse.StandardDates.LastDateStarts);
}
public async Task Then_The_Api_Is_Called_And_Email_Sent_If_ResponseCode_Is_Ok_And_Audit_Created(
StopEmployerDemandCommand command,
GetEmployerDemandResponse getDemandResponse,
GetEmployerDemandResponse stopResponseBody,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > mockApiClient,
[Frozen] Mock <INotificationService> mockNotificationService,
StopEmployerDemandCommandHandler handler)
{
//Arrange
getDemandResponse.Stopped = false;
var stopResponse = new ApiResponse <string>(JsonConvert.SerializeObject(stopResponseBody), HttpStatusCode.OK, "");
mockApiClient
.Setup(client => client.PatchWithResponseCode(
It.Is <PatchCourseDemandRequest>(c => c.PatchUrl.Contains(command.EmployerDemandId.ToString()) &&
c.Data.FirstOrDefault().Path.Equals("Stopped") &&
c.Data.FirstOrDefault().Value.Equals(true)
)))
.ReturnsAsync(stopResponse);
mockApiClient
.Setup(client => client.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(request => request.GetUrl.Contains($"demand/{command.EmployerDemandId}"))))
.ReturnsAsync(getDemandResponse);
SendEmailCommand actualEmail = null;
mockNotificationService
.Setup(service => service.Send(It.IsAny <SendEmailCommand>()))
.Callback((SendEmailCommand args) => actualEmail = args)
.Returns(Task.CompletedTask);
var expectedEmail = new StopSharingEmployerDemandEmail(
stopResponseBody.ContactEmailAddress,
stopResponseBody.OrganisationName,
stopResponseBody.Course.Title,
stopResponseBody.Course.Level,
stopResponseBody.Location.Name,
stopResponseBody.NumberOfApprentices,
stopResponseBody.StartSharingUrl);
//Act
var actual = await handler.Handle(command, CancellationToken.None);
//Assert
actual.EmployerDemand.Should().BeEquivalentTo(stopResponseBody);
actualEmail.Tokens.Should().BeEquivalentTo(expectedEmail.Tokens);
actualEmail.RecipientsAddress.Should().BeEquivalentTo(expectedEmail.RecipientAddress);
actualEmail.TemplateId.Should().BeEquivalentTo(expectedEmail.TemplateId);
mockApiClient.Verify(
x => x.PostWithResponseCode <object>(It.Is <PostEmployerDemandNotificationAuditRequest>(c =>
c.PostUrl.Contains($"{command.EmployerDemandId}/notification-audit/{command.Id}?notificationType={(short)NotificationType.StoppedByUser}"))), Times.Once);
}
public async Task Then_The_Command_Is_Handled_And_Api_Called(
VerifyEmployerDemandCommand command,
string patchResponse,
GetEmployerDemandResponse getDemandResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > apiClient,
[Frozen] Mock <INotificationService> notificationService,
VerifyEmployerDemandCommandHandler handler)
{
//Arrange
getDemandResponse.EmailVerified = false;
var apiResponse = new ApiResponse <string>(patchResponse, HttpStatusCode.OK, null);
apiClient.Setup(
x => x.PatchWithResponseCode(It.Is <PatchCourseDemandRequest>(c =>
c.PatchUrl.Contains($"api/demand/{command.Id}") &&
c.Data.FirstOrDefault().Path.Equals("EmailVerified") &&
c.Data.FirstOrDefault().Value.Equals(true)
))).ReturnsAsync(apiResponse);
apiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{command.Id}"))))
.ReturnsAsync(getDemandResponse);
SendEmailCommand actualEmail = null;
notificationService
.Setup(service => service.Send(It.IsAny <SendEmailCommand>()))
.Callback((SendEmailCommand args) => actualEmail = args)
.Returns(Task.CompletedTask);
var expectedEmail = new CreateDemandConfirmationEmail(
getDemandResponse.ContactEmailAddress,
getDemandResponse.OrganisationName,
getDemandResponse.Course.Title,
getDemandResponse.Course.Level,
getDemandResponse.Location.Name,
getDemandResponse.NumberOfApprentices,
getDemandResponse.StopSharingUrl);
//Act
var actual = await handler.Handle(command, CancellationToken.None);
//Assert
actual.EmployerDemand.Should().BeEquivalentTo(getDemandResponse, options => options.Excluding(c => c.EmailVerified));
actual.EmployerDemand.EmailVerified.Should().BeTrue();
actualEmail.Tokens.Should().BeEquivalentTo(expectedEmail.Tokens);
actualEmail.RecipientsAddress.Should().BeEquivalentTo(expectedEmail.RecipientAddress);
actualEmail.TemplateId.Should().BeEquivalentTo(expectedEmail.TemplateId);
}
public void Then_The_Fields_Are_Mapped(GetEmployerDemandResponse source)
{
//Act
var actual = (GetCourseDemandResponse)source;
//Assert
actual.Should().BeEquivalentTo(source, options => options
.Excluding(c => c.Location)
.Excluding(c => c.Course)
.Excluding(c => c.ContactEmailAddress)
.Excluding(c => c.StopSharingUrl)
.Excluding(c => c.StartSharingUrl)
.Excluding(c => c.Stopped)
.Excluding(c => c.ExpiredCourseDemandId)
.Excluding(c => c.LastStartDate)
);
actual.ContactEmail.Should().Be(source.ContactEmailAddress);
}
public async Task Then_The_Data_Is_Returned_From_The_Api(
GetCourseDemandQuery query,
GetEmployerDemandResponse getDemandResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > apiClient,
GetCourseDemandQueryHandler handler)
{
//Arrange
apiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{query.Id}"))))
.ReturnsAsync(getDemandResponse);
//act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.EmployerDemand.Should().BeEquivalentTo(getDemandResponse);
}
public async Task Then_The_Command_Is_Handled_And_EmailSent_And_Demand_Updated(
GetEmployerDemandResponse response,
SendAutomaticEmployerDemandDemandCutOffCommand command,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > employerDemandApiClient,
[Frozen] Mock <INotificationService> notificationService,
SendAutomaticEmployerDemandDemandCutOffCommandHandler handler)
{
//Arrange
employerDemandApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(It.Is <GetEmployerDemandRequest>(c =>
c.GetUrl.Contains(command.EmployerDemandId.ToString()))))
.ReturnsAsync(response);
SendEmailCommand actualEmail = null;
notificationService
.Setup(service => service.Send(It.IsAny <SendEmailCommand>()))
.Callback((SendEmailCommand args) => actualEmail = args)
.Returns(Task.CompletedTask);
var expectedEmail = new StopSharingExpiredEmployerDemandEmail(
response.ContactEmailAddress,
response.OrganisationName,
response.Course.Title,
response.Course.Level,
response.Location.Name,
response.NumberOfApprentices,
response.StartSharingUrl);
//Act
await handler.Handle(command, CancellationToken.None);
//Assert
employerDemandApiClient.Verify(
x => x.PostWithResponseCode <object>(It.Is <PostEmployerDemandNotificationAuditRequest>(c =>
c.PostUrl.Contains($"{command.EmployerDemandId}/notification-audit/{command.Id}?notificationType={(short)NotificationType.StoppedAutomaticCutOff}"))), Times.Once);
employerDemandApiClient.Verify(
x => x.PatchWithResponseCode(It.Is <PatchCourseDemandRequest>(c =>
c.PatchUrl.Contains($"api/demand/{command.EmployerDemandId}") &&
c.Data.FirstOrDefault().Path.Equals("Stopped") &&
c.Data.FirstOrDefault().Value.Equals(true)
)), Times.Once);
actualEmail.Tokens.Should().BeEquivalentTo(expectedEmail.Tokens);
actualEmail.RecipientsAddress.Should().BeEquivalentTo(expectedEmail.RecipientAddress);
actualEmail.TemplateId.Should().BeEquivalentTo(expectedEmail.TemplateId);
}
public async Task Then_A_Notification_Is_Sent_And_Api_Called(
GetEmployerDemandResponse response,
SendEmployerDemandEmailReminderCommand command,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > employerDemandApiClient,
[Frozen] Mock <INotificationService> notificationService,
SendEmployerDemandEmailReminderCommandHandler handler)
{
//Arrange
employerDemandApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(It.Is <GetEmployerDemandRequest>(c =>
c.GetUrl.Contains(command.EmployerDemandId.ToString()))))
.ReturnsAsync(response);
SendEmailCommand actualEmail = null;
notificationService
.Setup(service => service.Send(It.IsAny <SendEmailCommand>()))
.Callback((SendEmailCommand args) => actualEmail = args)
.Returns(Task.CompletedTask);
var expectedEmail = new CreateEmployerDemandReminderEmail(
response.ContactEmailAddress,
response.OrganisationName,
response.Course.Title,
response.Course.Level,
response.Location.Name,
response.NumberOfApprentices,
response.StopSharingUrl);
//Act
await handler.Handle(command, CancellationToken.None);
//Assert
employerDemandApiClient.Verify(
x => x.PostWithResponseCode <object>(It.Is <PostEmployerDemandNotificationAuditRequest>(c =>
c.PostUrl.Contains($"{command.EmployerDemandId}/notification-audit/{command.Id}?notificationType={(short)NotificationType.Reminder}"))), Times.Once);
actualEmail.Tokens.Should().BeEquivalentTo(expectedEmail.Tokens);
actualEmail.RecipientsAddress.Should().BeEquivalentTo(expectedEmail.RecipientAddress);
actualEmail.TemplateId.Should().BeEquivalentTo(expectedEmail.TemplateId);
}
public async Task And_Demand_Already_Stopped_Then_Not_Send_Email(
StopEmployerDemandCommand command,
GetEmployerDemandResponse getDemandResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > mockApiClient,
[Frozen] Mock <INotificationService> mockNotificationService,
StopEmployerDemandCommandHandler handler)
{
//Arrange
getDemandResponse.Stopped = true;
mockApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{command.EmployerDemandId}"))))
.ReturnsAsync(getDemandResponse);
//Act
var actual = await handler.Handle(command, CancellationToken.None);
//Assert
mockApiClient.Verify(client => client.PatchWithResponseCode(It.IsAny <PatchCourseDemandRequest>()),
Times.Never);
mockNotificationService.Verify(service => service.Send(It.IsAny <SendEmailCommand>()),
Times.Never);
actual.EmployerDemand.Should().BeEquivalentTo(getDemandResponse);
}
