public async Task Then_Gets_Courses_And_Demands_From_Mediator(
int ukprn,
int courseId,
string location,
int locationRadius,
List <string> routes,
GetAggregatedCourseDemandListResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetAggregatedCourseDemandListQuery>(query =>
query.Ukprn == ukprn &&
query.CourseId == courseId &&
query.LocationName == location &&
query.LocationRadius == locationRadius),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetAggregatedCourseDemandList(ukprn, courseId, location, locationRadius, routes) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetAggregatedCourseDemandListResponse;
model !.TrainingCourses.Should().BeEquivalentTo(mediatorResult.Courses.Select(item => (GetCourseListItem)item));
model !.AggregatedCourseDemands.Should().BeEquivalentTo(mediatorResult.AggregatedCourseDemands.Select(response => (GetAggregatedCourseDemandSummary)response));
model !.Total.Should().Be(mediatorResult.Total);
model !.TotalFiltered.Should().Be(mediatorResult.TotalFiltered);
model !.Location.Should().BeEquivalentTo((GetLocationSearchResponseItem)mediatorResult.LocationItem);
model !.Routes.Should().BeEquivalentTo(mediatorResult.Routes);
}
public async Task Then_The_Command_Is_Sent_To_Mediator_And_Response_Returned(
CreateCourseDemandCommandResponse response,
CourseDemandRequest request,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
response.IsCreated = true;
mediator.Setup(x => x.Send(It.Is <CreateCourseDemandCommand>(c =>
c.CourseDemand.Id.Equals(request.Id) &&
c.CourseDemand.OrganisationName.Equals(request.OrganisationName) &&
c.CourseDemand.ContactEmailAddress.Equals(request.ContactEmailAddress) &&
c.CourseDemand.NumberOfApprentices.Equals(request.NumberOfApprentices) &&
c.CourseDemand.Course.Id.Equals(request.Course.Id) &&
c.CourseDemand.Course.Title.Equals(request.Course.Title) &&
c.CourseDemand.Course.Level.Equals(request.Course.Level) &&
c.CourseDemand.Course.Route.Equals(request.Course.Route) &&
c.CourseDemand.Location.Name.Equals(request.Location.Name) &&
c.CourseDemand.Location.Lat == request.Location.LocationPoint.GeoPoint.First() &&
c.CourseDemand.Location.Lon == request.Location.LocationPoint.GeoPoint.Last()
), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
//Act
var actual = await controller.CreateDemand(request) as CreatedResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.Created);
actual.Value.Should().BeEquivalentTo(new { response.Id });
}
public async Task Then_Returns_List_From_Handler(
int ukprn,
int?courseId,
double?lat,
double?lon,
int radius,
GetAggregatedCourseDemandListResult resultFromMediator,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetAggregatedCourseDemandListQuery>(query =>
query.Ukprn == ukprn &&
query.CourseId == courseId &&
query.Lat.Equals(lat) &&
query.Lon.Equals(lon) &&
query.Radius == radius),
It.IsAny <CancellationToken>()))
.ReturnsAsync(resultFromMediator);
var result = await controller.GetAggregatedCourseDemandList(ukprn, courseId, lat, lon, radius) as ObjectResult;
result.Should().NotBeNull();
result !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = result.Value as GetAggregatedCourseDemandListResponse;
model !.AggregatedCourseDemandList.Should().BeEquivalentTo(
resultFromMediator.AggregatedCourseDemandList.Select(summary =>
(GetAggregatedCourseDemandSummaryResponse)summary));
model.TotalFiltered.Should().Be(resultFromMediator.AggregatedCourseDemandList.Count());
model.Total.Should().Be(resultFromMediator.Total);
}
public async Task Then_The_Demand_Is_Returned_From_Mediator(
int id,
GetStartCourseDemandQueryResult queryResult,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
mediator.Setup(x => x.Send(It.Is <GetStartCourseDemandQuery>(c => c.CourseId.Equals(id)), CancellationToken.None))
.ReturnsAsync(queryResult);
//Act
var actual = await controller.StartDemand(id) as ObjectResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.OK);
var actualModel = actual.Value as GetStartCourseDemandResponse;
Assert.IsNotNull(actualModel);
actualModel.TrainingCourse.Should().BeEquivalentTo(queryResult.Course, options => options
.Excluding(c => c.LarsCode)
.Excluding(c => c.StandardUId)
.Excluding(c => c.StandardDates)
);
actualModel.TrainingCourse.LastStartDate.Should().Be(queryResult.Course.StandardDates.LastDateStarts);
}
public void GetAllDemandes()
{
var mock = new Mock <IRepository <Demand> >();
mock.Setup(repo => repo.GetAll()).Returns(GetAllTest());
var factoryMock = new Mock <IRepositoryFactory>();
factoryMock.Setup(f => f.GetRepository <Demand>()).Returns(mock.Object);
_demandController = new DemandController(factoryMock.Object);
var json = _demandController.GetAll();
var demand = json.Value as List <Demand>;
Assert.NotNull(json);
Assert.NotNull(demand);
Assert.AreEqual(demand.Count, 2);
//var mock1 = new Mock<IRepository<Demand>>();
//mock1.Setup(repo => repo.GetAll().FirstOrDefault()).Returns(GetFirstOrDefaultTest(1));
//var factoryMock1 = new Mock<IRepositoryFactory>();
//factoryMock1.Setup(f => f.GetRepository<Demand>()).Returns(mock1.Object);
//_demandController = new DemandController(factoryMock1.Object);
//json = _demandController.GetAll();
//demand = json.Value as List<Demand>;
//Assert.AreEqual();
}
public async Task Then_If_Validation_Exception_Bad_Request_Returned(
string errorKey,
CourseDemandRequest request,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
var validationResult = new ValidationResult {
ValidationDictionary = { { errorKey, "Some error" } }
};
mediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateCourseDemandCommand>(),
It.IsAny <CancellationToken>()))
.Throws(new ValidationException(validationResult.DataAnnotationResult, null, null));
//Act
var actual = await controller.CreateDemand(request) as ObjectResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
actual.Value.ToString().Should().Contain(errorKey);
}
public async Task Then_Gets_Employer_Course_Demands_From_Mediator(
int ukprn,
int courseId,
string location,
int locationRadius,
GetEmployerCourseProviderDemandQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetEmployerCourseProviderDemandQuery>(query =>
query.Ukprn == ukprn &&
query.CourseId == courseId &&
query.LocationName == location &&
query.LocationRadius == locationRadius),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetEmployerCourseProviderDemand(ukprn, courseId, location, locationRadius) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetProviderEmployerCourseDemandListResponse;
model !.TrainingCourse.Should().BeEquivalentTo((GetCourseListItem)mediatorResult.Course);
model !.ProviderEmployerDemandDetailsList.Should().BeEquivalentTo(mediatorResult.EmployerCourseDemands.Select(response => (GetProviderEmployerDemandDetailsListItem)response));
model !.Total.Should().Be(mediatorResult.Total);
model !.TotalFiltered.Should().Be(mediatorResult.TotalFiltered);
model !.Location.Should().BeEquivalentTo((GetLocationSearchResponseItem)mediatorResult.Location);
model !.ProviderContactDetails.Should().BeEquivalentTo((GetProviderContactDetails)mediatorResult.ProviderDetail);
}
public async Task Then_The_Command_Is_Processed_By_Mediator_And_Id_Returned(
Guid returnId,
CreateCourseDemandRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <RegisterDemandCommand>(command =>
command.Id == request.Id &&
command.OrganisationName.Equals(request.OrganisationName) &&
command.ContactEmailAddress.Equals(request.ContactEmailAddress) &&
command.NumberOfApprentices.Equals(request.NumberOfApprentices) &&
command.Lat.Equals(request.LocationItem.Location.GeoPoint.First()) &&
command.Lon.Equals(request.LocationItem.Location.GeoPoint.Last()) &&
command.LocationName.Equals(request.LocationItem.Name) &&
command.CourseId.Equals(request.TrainingCourse.Id) &&
command.CourseTitle.Equals(request.TrainingCourse.Title) &&
command.CourseLevel.Equals(request.TrainingCourse.Level) &&
command.CourseRoute.Equals(request.TrainingCourse.Route) &&
command.ConfirmationLink.Equals(request.ResponseUrl) &&
command.StopSharingUrl.Equals(request.StopSharingUrl) &&
command.StartSharingUrl.Equals(request.StartSharingUrl) &&
command.ExpiredCourseDemandId.Equals(request.ExpiredCourseDemandId) &&
command.EntryPoint.Equals(request.EntryPoint)
),
It.IsAny <CancellationToken>())).ReturnsAsync((returnId));
var controllerResult = await controller.CreateCourseDemand(request) as CreatedResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Created);
controllerResult.Value.Should().Be(returnId);
}
public void Then_Returns_OK(
[Greedy] DemandController controller)
{
var result = controller.ShowDemand() as OkResult;
result.Should().NotBeNull();
result !.StatusCode.Should().Be((int)HttpStatusCode.OK);
}
public async Task Then_If_There_Is_An_Error_A_Bad_Request_Is_Returned(
Guid id,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <VerifyEmployerDemandCommand>(),
It.IsAny <CancellationToken>())).ThrowsAsync(new Exception());
var controllerResult = await controller.VerifyCourseDemand(id) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public void Create2()
{
Demand demand = new Demand()
{
Id = 1
};
var mock = new Mock <IRepository <Demand> >();
mock.Setup(repo => repo.Create(demand));
var factoryMock = new Mock <IRepositoryFactory>();
factoryMock.Setup(f => f.GetRepository <Demand>()).Returns(mock.Object);
_demandController = new DemandController(factoryMock.Object);
//Assert.AreEqual(demand, factoryMock);
}
public async Task Then_The_Command_Is_Processed_By_Mediator(
Guid employerDemandId,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <AnonymiseDemandCommand>(command => command.EmployerDemandId == employerDemandId),
It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
var controllerResult = await controller.AnonymiseEmployerDemand(employerDemandId) as OkResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
}
public async Task Then_InternalServerError_Returned_If_An_Exception_Is_Thrown(
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
mediator.Setup(x => x.Send(It.IsAny <GetCourseDemandsOlderThan3YearsQuery>(), CancellationToken.None))
.ThrowsAsync(new Exception());
//Act
var actual = await controller.CourseDemandsOlderThan3Years() as StatusCodeResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task And_Exception_Then_Returns_Bad_Request(
int courseId,
string locationName,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetRegisterDemandQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.Create(courseId, locationName) as BadRequestResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task Then_If_Exception_Returned_Then_Internal_Error_Response_Returned(
int id,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
mediator.Setup(x => x.Send(It.Is <GetStartCourseDemandQuery>(c => c.CourseId.Equals(id)), CancellationToken.None))
.ThrowsAsync(new Exception());
//Act
var actual = await controller.StartDemand(id) as StatusCodeResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task Then_If_An_Error_Then_An_InternalServer_Error_Is_Returned(
CourseDemandRequest request,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
mediator.Setup(x => x.Send(It.IsAny <CreateCourseDemandCommand>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new Exception());
//Act
var actual = await controller.CreateDemand(request) as StatusCodeResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task Then_If_Null_Is_Returned_Then_Conflict_returned(
Guid returnId,
CreateCourseDemandRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <RegisterDemandCommand>(command =>
command.Id == request.Id),
It.IsAny <CancellationToken>())).ReturnsAsync((Guid?)null);
var controllerResult = await controller.CreateCourseDemand(request) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Conflict);
}
public void GetDemand()
{
var mock = new Mock <IRepository <Demand> >();
mock.Setup(repo => repo.GetById(It.IsAny <int>())).Returns(GetByIdTest(1));
var factoryMock = new Mock <IRepositoryFactory>();
factoryMock.Setup(f => f.GetRepository <Demand>()).Returns(mock.Object);
_demandController = new DemandController(factoryMock.Object);
var json = _demandController.Get(1);
var demand = json.Value as Demand;
Assert.NotNull(json);
Assert.NotNull(demand);
Assert.AreEqual(demand.Id, 1);
}
public async Task Then_If_There_Is_A_HttpException_It_Is_Returned(
string errorContent,
CreateCourseDemandRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <RegisterDemandCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(new HttpRequestContentException("Error", HttpStatusCode.BadRequest, errorContent));
var controllerResult = await controller.CreateCourseDemand(request) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
controllerResult.Value.Should().Be(errorContent);
}
public async Task Then_The_Demands_Are_Returned_From_Mediator(
GetCourseDemandsOlderThan3YearsResult queryResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
//Arrange
mockMediator
.Setup(x => x.Send(It.IsAny <GetCourseDemandsOlderThan3YearsQuery>(), CancellationToken.None))
.ReturnsAsync(queryResult);
//Act
var actual = await controller.CourseDemandsOlderThan3Years() as ObjectResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.OK);
actual.Value.Should().BeEquivalentTo(new{ queryResult.EmployerDemandIds });
}
public async Task Then_If_Null_Returned_Then_Not_Found_Response_Returned(
Guid id,
GetCourseDemandQueryResult queryResult,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
queryResult.EmployerDemand = null;
mediator.Setup(x => x.Send(It.Is <GetCourseDemandQuery>(c => c.Id.Equals(id)), CancellationToken.None))
.ReturnsAsync(queryResult);
//Act
var actual = await controller.Get(id) as NotFoundResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task And_Exception_Then_Returns_Internal_Server_Error(
int ukprn,
int courseId,
string location,
int locationRadius,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetEmployerCourseProviderDemandQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetEmployerCourseProviderDemand(ukprn, courseId, location, locationRadius) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task And_Exception_Then_Returns_Bad_Request(
int ukprn,
int courseId,
string location,
int locationRadius,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetAggregatedCourseDemandListQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetAggregatedCourseDemandList(ukprn, courseId, location, locationRadius) as BadRequestResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task Then_The_Demand_Is_Returned_From_Mediator(
uint ageOfDemandInDays,
GetUnmetCourseDemandsQueryResult queryResult,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
mediator.Setup(x => x.Send(It.Is <GetUnmetCourseDemandsQuery>(c => c.AgeOfDemandInDays.Equals(ageOfDemandInDays)), CancellationToken.None))
.ReturnsAsync(queryResult);
//Act
var actual = await controller.UnmetCourseDemands(ageOfDemandInDays) as ObjectResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.OK);
actual.Value.Should().BeEquivalentTo(new{ queryResult.EmployerDemandIds });
}
public async Task Then_The_Command_Is_Processed_By_Mediator_And_Id_Returned(
Guid id,
Guid courseDemandId,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
//Act
var controllerResult = await controller.SendAutomaticCutOffEmail(courseDemandId, id) as CreatedResult;
//Assert
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Created);
controllerResult.Value.Should().BeEquivalentTo(new { id });
mockMediator
.Verify(mediator => mediator.Send(
It.Is <SendAutomaticEmployerDemandDemandCutOffCommand>(command =>
command.Id == id &&
command.EmployerDemandId == courseDemandId
),
It.IsAny <CancellationToken>()));
}
public async Task Then_The_Command_Is_Processed_By_Mediator_And_Model_Returned(
Guid employerDemandId,
StopEmployerDemandCommandResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <StopEmployerDemandCommand>(command =>
command.EmployerDemandId == employerDemandId &&
command.Id != Guid.Empty
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.StopEmployerDemand(employerDemandId) as OkObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.OK);
controllerResult.Value.Should().BeEquivalentTo((GetCourseDemandResponse)mediatorResult.EmployerDemand);
}
public void Create()
{
var memoryStore = new List <Demand>();
Demand demandStub = new Demand {
Id = 1
};
var mock = new Mock <IRepository <Demand> >();
mock.Setup(repo => repo.GetAll()).Returns(memoryStore.AsQueryable());
mock.Setup(repo => repo.Create(It.IsAny <Demand>())).Returns((Demand demand) => {
demand.Id = 1;
memoryStore.Add(demand);
return(demand);
});
var factoryMock = new Mock <IRepositoryFactory>();
factoryMock.Setup(f => f.GetRepository <Demand>()).Returns(mock.Object);
_demandController = new DemandController(factoryMock.Object);
var emptyJson = _demandController.GetAll();
Assert.IsNotNull(emptyJson);
var emptyStore = emptyJson.Value as List <Demand>;
Assert.IsNotNull(emptyStore);
Assert.AreEqual(emptyStore.Count, 0);
var json = _demandController.Create(demandStub);
Assert.IsNotNull(json);
var result = json.Value as Demand;
Assert.NotNull(result);
Assert.AreEqual(result.Id, 1);
Assert.AreEqual(result.Client, demandStub.Client);
var notEmptyJson = _demandController.GetAll();
Assert.IsNotNull(notEmptyJson);
var notEmptyStore = notEmptyJson.Value as List <Demand>;
Assert.IsNotNull(notEmptyStore);
Assert.AreEqual(notEmptyStore.Count, 1);
}
public async Task Then_The_Demand_Is_Returned_From_Mediator(
Guid id,
GetCourseDemandQueryResult queryResult,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
mediator.Setup(x => x.Send(It.Is <GetCourseDemandQuery>(c => c.Id.Equals(id)), CancellationToken.None))
.ReturnsAsync(queryResult);
//Act
var actual = await controller.Get(id) as ObjectResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.OK);
var actualModel = actual.Value as GetCourseDemandResponse;
Assert.IsNotNull(actualModel);
actualModel.Id.Should().Be(queryResult.EmployerDemand.Id);
}
public async Task Then_The_Command_Is_Processed_By_Mediator_And_Id_Returned(
Guid id,
VerifyEmployerDemandCommandResult response,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] DemandController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <VerifyEmployerDemandCommand>(command =>
command.Id == id
),
It.IsAny <CancellationToken>())).ReturnsAsync(response);
var controllerResult = await controller.VerifyCourseDemand(id) as CreatedResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Created);
var actualModel = controllerResult.Value as VerifyCourseDemandResponse;
Assert.IsNotNull(actualModel);
actualModel.Id.Should().Be(response.EmployerDemand.Id);
}
public async Task Then_The_Command_Is_Sent_To_Mediator_And_Response_Returned_And_If_Not_Created_Accepted_Returned(
CreateCourseDemandCommandResponse response,
CourseDemandRequest request,
[Frozen] Mock <IMediator> mediator,
[Greedy] DemandController controller)
{
//Arrange
response.IsCreated = false;
mediator.Setup(x => x.Send(It.Is <CreateCourseDemandCommand>(c =>
c.CourseDemand.Id.Equals(request.Id)
), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
//Act
var actual = await controller.CreateDemand(request) as AcceptedResult;
//Assert
Assert.IsNotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
actual.Value.Should().BeEquivalentTo(new { response.Id });
}
