public async Task Then_Gets_Training_Course_And_Providers_From_Mediator(
int standardCode,
GetTrainingCourseProvidersResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProvidersQuery>(c => c.Id.Equals(standardCode)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviders(standardCode) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseProvidersResponse;
Assert.IsNotNull(model);
model.TrainingCourse.Should().BeEquivalentTo(mediatorResult.Course, options => options
.Excluding(tc => tc.ApprenticeshipFunding)
.Excluding(tc => tc.StandardDates)
);
model.TrainingCourseProviders.Should()
.BeEquivalentTo(mediatorResult.Providers,
options => options.Excluding(c => c.Ukprn));
model.Total.Should().Be(mediatorResult.Total);
}
public async Task Then_If_There_Is_No_Course_Or_Provider_Then_Not_Found_Returned(
int standardCode,
int providerId,
string location,
double lat,
double lon,
Guid?shortlistUserId,
GetTrainingCourseProviderResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mediatorResult.ProviderStandard = null;
mediatorResult.Course = null;
mediatorResult.TotalProviders = 0;
mediatorResult.TotalProvidersAtLocation = 0;
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProviderQuery>(
c
=> c.CourseId.Equals(standardCode) &&
c.ProviderId.Equals(providerId) &&
c.Location.Equals(location) &&
c.Lat.Equals(lat) &&
c.Lon.Equals(lon) &&
c.ShortlistUserId.Equals(shortlistUserId)
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviderCourse(standardCode, providerId, location, lat, lon, shortlistUserId) as StatusCodeResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task Then_Gets_Training_Courses_From_Mediator_With_Keyword_And_RouteIds_And_Levels_And_OrderBy_If_Supplied(
string keyword,
List <int> levels,
List <Guid> routeIds,
GetTrainingCoursesListResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCoursesListQuery>(c =>
c.Keyword.Equals(keyword) &&
c.RouteIds.Equals(routeIds) &&
c.Levels.Equals(levels) &&
c.OrderBy.Equals(OrderBy.Score)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetList(keyword, routeIds, levels, "Relevance") as ObjectResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCoursesListResponse;
model.TrainingCourses.Should().BeEquivalentTo(mediatorResult.Courses, options => options
.Excluding(tc => tc.ApprenticeshipFunding)
.Excluding(tc => tc.StandardDates)
);
model.Total.Should().Be(mediatorResult.Total);
model.TotalFiltered.Should().Be(mediatorResult.TotalFiltered);
}
public async Task Then_Gets_Standards_By_Sector_From_Mediator(
string sector,
GetStandardsQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetStandardsQuery>(c => c.Sector.Equals(sector)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetStandardsBySector(sector) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetStandardsResponse;
Assert.IsNotNull(model);
var response = mediatorResult.Standards.Select(s => new GetStandardsResponseItem {
Id = s.LarsCode
});
model.Standards.Should().BeEquivalentTo(response);
}
public async Task Then_Gets_Training_Course_And_Providers_Count_From_Mediator(
int standardCode,
double lat,
double lon,
Guid?shortlistUserId,
GetTrainingCourseResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseQuery>(c =>
c.Id.Equals(standardCode) &&
c.Lat.Equals(lat) &&
c.Lon.Equals(lon) &&
c.ShortlistUserId.Equals(shortlistUserId)
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.Get(standardCode, lat, lon, shortlistUserId) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseResponse;
Assert.IsNotNull(model);
model.TrainingCourse.Should().BeEquivalentTo((GetTrainingCourseListItem)mediatorResult.Course);
model.TrainingCourse.Id.Should().Be(mediatorResult.Course.LarsCode);
model.ProvidersCount.TotalProviders.Should().Be(mediatorResult.ProvidersCount);
model.ProvidersCount.ProvidersAtLocation.Should().Be(mediatorResult.ProvidersCountAtLocation);
model.ShortlistItemCount.Should().Be(mediatorResult.ShortlistItemCount);
model.ShowEmployerDemand.Should().Be(mediatorResult.ShowEmployerDemand);
}
public async Task And_Then_No_Standard_Is_Returned_From_Mediator(
string courseCode,
[Greedy] TrainingCoursesController controller)
{
var controllerResult = await controller.GetStandard(courseCode) as NotFoundResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task Then_Gets_Training_Course_And_Providers_From_Mediator(
int standardCode,
int providerId,
string location,
double lat,
double lon,
Guid?shortlistUserId,
GetTrainingCourseProviderResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProviderQuery>(
c
=> c.CourseId.Equals(standardCode) &&
c.ProviderId.Equals(providerId) &&
c.Location.Equals(location) &&
c.Lat.Equals(lat) &&
c.Lon.Equals(lon) &&
c.ShortlistUserId.Equals(shortlistUserId)
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviderCourse(standardCode, providerId, location, lat, lon, shortlistUserId) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseProviderResponse;
Assert.IsNotNull(model);
model.TrainingCourse.Should().BeEquivalentTo((GetTrainingCourseListItem)mediatorResult.Course);
model.TrainingCourseProvider.Should()
.BeEquivalentTo(mediatorResult.ProviderStandard,
options => options
.Excluding(c => c.StandardInfoUrl)
.Excluding(c => c.StandardId)
.Excluding(c => c.AchievementRates)
.Excluding(c => c.Ukprn)
.Excluding(c => c.DeliveryTypes)
.Excluding(c => c.EmployerFeedback)
.Excluding(c => c.ApprenticeFeedback)
.Excluding(c => c.ProviderAddress)
);
model.AdditionalCourses.Courses.Should().BeEquivalentTo(mediatorResult.AdditionalCourses);
model.TrainingCourse.Should().NotBeNull();
model.TrainingCourse.Id.Should().Be(mediatorResult.Course.LarsCode);
model.ProvidersCount.ProvidersAtLocation.Should().Be(mediatorResult.TotalProvidersAtLocation);
model.ProvidersCount.TotalProviders.Should().Be(mediatorResult.TotalProviders);
model.Location.Location.GeoPoint.Should().BeEquivalentTo(mediatorResult.Location.GeoPoint);
model.Location.Name.Should().Be(mediatorResult.Location.Name);
model.TrainingCourseProvider.EmployerFeedback.Should().NotBeNull();
model.TrainingCourseProvider.ApprenticeFeedback.Should().NotBeNull();
model.TrainingCourseProvider.ProviderAddress.Should().BeEquivalentTo(mediatorResult.ProviderStandard.ProviderAddress);
model.ShortlistItemCount.Should().Be(mediatorResult.ShortlistItemCount);
}
public async Task And_Exception_Then_Returns_Internal_Server_Error(
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetActiveTrainingCoursesQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetActiveList() as StatusCodeResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task And_Exception_Then_Returns_Bad_Request(
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetStandardsQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetStandards() as BadRequestResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task And_Invalid_StandardId_Then_Returns_Not_Found(
string id,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetStandardDetailsQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetStandardDetailsResult(null));
var controllerResult = await controller.GetStandardById(id) as NotFoundResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task And_Exception_Then_Returns_Bad_Request(
int standardCode,
int providerId,
string location,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetTrainingCourseProviderQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetProviderCourse(standardCode, providerId, location) as StatusCodeResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task And_Exception_Then_Returns_Bad_Request(
int id,
GetCourseProvidersRequest request,
List <DeliveryModeType> deliveryModes,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetTrainingCourseProvidersQuery>(),
It.IsAny <CancellationToken>()))
.Throws <InvalidOperationException>();
var controllerResult = await controller.GetProviders(id, request) as StatusCodeResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
}
public async Task Then_Nulls_Are_Filtered_Out_From_The_Providers_List_And_The_Filtered_Count_Returned(
int id,
GetCourseProvidersRequest request,
GetProvidersListItem provider1,
GetProvidersListItem provider2,
ProviderCourseSortOrder.SortOrder sortOrder,
GetTrainingCourseProvidersResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
request.DeliveryModes = new List <DeliveryModeType>
{
DeliveryModeType.Workplace
};
provider1.DeliveryTypes = provider1.DeliveryTypes.Select(c =>
{
c.DeliveryModes = "100PercentEmployer";
return(c);
}).ToList();
provider2.DeliveryTypes = provider2.DeliveryTypes.Select(c =>
{
c.DeliveryModes = "DayRelease";
return(c);
}).ToList();
mediatorResult.Providers = new List <GetProvidersListItem> {
provider1, provider2
};
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProvidersQuery>(c => c.Id.Equals(id)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviders(id, request) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseProvidersResponse;
Assert.IsNotNull(model);
model.TrainingCourseProviders.Count().Should().Be(1);
model.Total.Should().Be(mediatorResult.Total);
model.TotalFiltered.Should().Be(model.TrainingCourseProviders.Count());
}
public async Task Then_Gets_Training_Course_And_Providers_From_Mediator(
int id,
GetCourseProvidersRequest request,
GetTrainingCourseProvidersResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
request.DeliveryModes = new List <DeliveryModeType>();
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProvidersQuery>(c =>
c.Id.Equals(id) &&
c.Location.Equals(request.Location) &&
c.SortOrder == (short)request.SortOrder &&
c.Lat.Equals(request.Lat) &&
c.Lon.Equals(request.Lon) &&
c.ShortlistUserId.Equals(request.ShortlistUserId)
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviders(id, request) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseProvidersResponse;
Assert.IsNotNull(model);
model.TrainingCourse.Should().BeEquivalentTo((GetTrainingCourseListItem)mediatorResult.Course);
model.TrainingCourseProviders.Should()
.BeEquivalentTo(mediatorResult.Providers,
options => options.Excluding(c => c.Ukprn)
.Excluding(c => c.AchievementRates)
.Excluding(c => c.DeliveryTypes)
.Excluding(c => c.FeedbackAttributes)
.Excluding(c => c.FeedbackRatings)
);
model.Total.Should().Be(mediatorResult.Total);
model.Location.Location.GeoPoint.Should().BeEquivalentTo(mediatorResult.Location.GeoPoint);
model.Location.Name.Should().Be(mediatorResult.Location.Name);
model.ShortlistItemCount.Should().Be(mediatorResult.ShortlistItemCount);
model.ShowEmployerDemand.Should().Be(mediatorResult.ShowEmployerDemand);
}
public async Task Then_If_Null_Response_Then_Not_Found_Returned(
int standardCode,
GetTrainingCourseResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseQuery>(c =>
c.Id.Equals(standardCode)
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetTrainingCourseResult());
var controllerResult = await controller.Get(standardCode) as StatusCodeResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public async Task Then_Gets_Standards_From_Mediator(
GetStandardsResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetStandardsQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetStandards() as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetStandardsListResponse;
Assert.IsNotNull(model);
model.Standards.Should().BeEquivalentTo(mediatorResult.Standards.Select(item => (GetStandardResponse)item));
}
public async Task Then_Get_Training_Course_From_Mediator(
string id,
GetStandardDetailsResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetStandardDetailsQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetStandardById(id) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetStandardDetailsResponse;
Assert.IsNotNull(model);
model.Should().BeEquivalentTo(mediatorResult.StandardDetails);
}
public async Task Then_Returns_Empty_List_If_None_Returned_From_Standards_By_Sector_From_Mediator(
string sector,
GetStandardsQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetStandardsQuery>(c => c.Sector.Equals(sector)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetStandardsQueryResult());
var controllerResult = await controller.GetStandardsBySector(sector) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetStandardsResponse;
Assert.IsNotNull(model);
model.Standards.Should().BeEmpty();
}
public async Task Then_Gets_Training_Courses_And_Sectors_And_Levels_From_Mediator_And_Shortlist_Count(
Guid?shortlistUserId,
GetTrainingCoursesListResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCoursesListQuery>(c => c.ShortlistUserId.Equals(shortlistUserId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetList(shortlistUserId : shortlistUserId) as ObjectResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCoursesListResponse;
model.TrainingCourses.Should().BeEquivalentTo(mediatorResult.Courses.Select(item => (GetTrainingCourseListItem)item));
model.Sectors.Should().BeEquivalentTo(mediatorResult.Sectors, options => options.Excluding(c => c.Name));
model.Levels.Should().BeEquivalentTo(mediatorResult.Levels);
model.ShortlistItemCount.Should().Be(mediatorResult.ShortlistItemCount);
}
public async Task Then_Gets_Training_Courses_And_Sectors_And_Levels_From_Mediator(
GetTrainingCoursesListResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetTrainingCoursesListQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetList() as ObjectResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCoursesListResponse;
model.TrainingCourses.Should().BeEquivalentTo(mediatorResult.Courses, options => options
.Excluding(tc => tc.ApprenticeshipFunding)
.Excluding(tc => tc.StandardDates)
);
model.Sectors.Should().BeEquivalentTo(mediatorResult.Sectors);
model.Levels.Should().BeEquivalentTo(mediatorResult.Levels);
}
public async Task Then_If_There_Is_No_Provider_For_That_Standard_Then_Null_Is_Returned(
int standardCode,
int providerId,
string location,
double lat,
double lon,
GetTrainingCourseProviderResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mediatorResult.ProviderStandard = null;
mediatorResult.TotalProviders = 0;
mediatorResult.TotalProvidersAtLocation = 0;
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProviderQuery>(
c
=> c.CourseId.Equals(standardCode) &&
c.ProviderId.Equals(providerId) &&
c.Location.Equals(location) &&
c.Lat.Equals(lat) &&
c.Lon.Equals(lon)
),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviderCourse(standardCode, providerId, location, lat, lon) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseProviderResponse;
Assert.IsNotNull(model);
model.TrainingCourse.Should().NotBeNull();
model.Location.Should().NotBeNull();
model.TrainingCourseProvider.Should().BeNull();
}
public async Task Then_gets_Standard_and_options_from_mediator(GetStandardOptionsResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator.Setup(mediator => mediator.Send(It.IsAny <GetStandardOptionsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetStandardOptionsList() as ObjectResult;
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetStandardOptionsResponse;
var expectedResponse = mediatorResult.StandardOptions.Select(s => new GetStandardOptionsItem
{
StandardUId = s.StandardUId,
LarsCode = s.LarsCode,
IfateReferenceNumber = s.IfateReferenceNumber,
Version = s.Version,
Options = s.Options
});
model.StandardOptions.Should().BeEquivalentTo(expectedResponse);
}
public async Task Then_Gets_Frameworks_From_Mediator(
GetFrameworksQueryResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetFrameworksQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetFrameworks() as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetFrameworksListResponse;
Assert.IsNotNull(model);
model.Frameworks.Should().BeEquivalentTo(mediatorResult.Frameworks, options => options
.Excluding(c => c.FundingPeriods)
.Excluding(c => c.IsActiveFramework)
.Excluding(c => c.CurrentFundingCap)
);
}
public async Task Then_FeedbackRating_Filter_Is_Applied(
int id,
GetCourseProvidersRequest request,
string location,
GetProvidersListItem provider1,
GetProvidersListItem provider2,
GetProvidersListItem provider3,
GetTrainingCourseProvidersResult mediatorResult,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] TrainingCoursesController controller)
{
request.ProviderRatings = new List <FeedbackRatingType>
{
FeedbackRatingType.Excellent,
FeedbackRatingType.Good
};
request.DeliveryModes = null;
provider1.FeedbackRatings = new List <GetFeedbackRatingItem>
{
new GetFeedbackRatingItem
{
FeedbackName = "Excellent",
FeedbackCount = 1,
}
};
provider2.FeedbackRatings = new List <GetFeedbackRatingItem>
{
new GetFeedbackRatingItem
{
FeedbackName = "Poor",
FeedbackCount = 1,
}
};
provider3.FeedbackRatings = new List <GetFeedbackRatingItem>
{
new GetFeedbackRatingItem
{
FeedbackName = "Good",
FeedbackCount = 1,
}
};
mediatorResult.Providers = new List <GetProvidersListItem> {
provider1, provider2, provider3
};
mockMediator
.Setup(mediator => mediator.Send(
It.Is <GetTrainingCourseProvidersQuery>(c => c.Id.Equals(id)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(mediatorResult);
var controllerResult = await controller.GetProviders(id, request) as ObjectResult;
Assert.IsNotNull(controllerResult);
controllerResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var model = controllerResult.Value as GetTrainingCourseProvidersResponse;
Assert.IsNotNull(model);
model.TrainingCourseProviders.Count().Should().Be(2);
model.Total.Should().Be(mediatorResult.Total);
model.TotalFiltered.Should().Be(model.TrainingCourseProviders.Count());
}
