public void ValidCourseId_ShouldNotHaveError()
{
var query = new GetCourseQuery {
CourseId = "courseId"
};
_sut.ShouldNotHaveValidationErrorFor(x => x.CourseId, query);
}
public void EmptyOrNullCourseId_ShouldHaveError(string courseId)
{
var query = new GetCourseQuery {
CourseId = courseId
};
_sut.ShouldHaveValidationErrorFor(x => x.CourseId, query);
}
public ActionResult <CourseDto> Get(int courseId, bool includeChapters = false)
{
var query = new GetCourseQuery(courseId, allowPublishedCourse: true, includeChapters: includeChapters);
return(getCourseQueryHandler.Handle(query)
.OnSuccess((course) => MapToDto(course, includeChapters))
.OnBoth((result) => responseHandler.GetResponse(result)));
}
public void SetUp()
{
_service = new Mock <IGetCourseService>();
_sut = new GetCourseQueryHandler(_service.Object);
_query = new GetCourseQuery {
CourseId = "courseId"
};
}
public async Task <ActionResult <CourseVM> > GetEventById(int id)
{
var getEventDetailQuery = new GetCourseQuery()
{
Id = id
};
return(Ok(await mediatr.Send(getEventDetailQuery)));
}
public async Task <IActionResult> Get(Guid id, GetCourseQuery query)
{
var result = await _mediatr.Send(new GetCourseQuery
{
CourseId = id
});
return(Ok(result));
}
public ActionResult <IEnumerable <ChapterDto> > GetAllByCourse([FromQuery] int courseId)
{
var query = new GetCourseQuery(courseId, allowPublishedCourse: true, includeChapters: true);
var courseResult = getCourseQueryHandler.Handle(query);
var chapterResult = courseResult.Success
? Result.Ok(mapper.Map <IEnumerable <ChapterDto> >(courseResult.Value.Chapters.OrderBy(x => x.Order)))
: Result.Fail <IEnumerable <ChapterDto> >(courseResult.Errors, courseResult.StatusCode);
return(responseHandler.GetResponse(chapterResult));
}
public async Task Then_Gets_Standard_From_Courses_Api(
GetCourseQuery query,
GetStandardsListItem apiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
GetCourseQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <GetStandardsListItem>(It.IsAny <GetStandardRequest>()))
.ReturnsAsync(apiResponse);
var result = await handler.Handle(query, CancellationToken.None);
result.Course.Should().BeEquivalentTo(apiResponse);
}
public async Task Then_Gets_Courses_From_Service(
GetCourseQuery query,
CourseListItem courseFromService,
[Frozen] Mock <ICourseService> mockService,
GetCourseQueryHandler handler)
{
mockService
.Setup(service => service.GetCourse(query.CourseId))
.ReturnsAsync(courseFromService);
var result = await handler.Handle(query, CancellationToken.None);
result.Course.Should().BeEquivalentTo(courseFromService);
}
public void GetCourse_WhenItsExist_ShouldSuccess()
{
using (var sut = new SystemUnderTest())
{
var course = sut.CreateCourse("Kurs Angielskiego A1", 2019, 350);
var unitOfWorkSubstitute = Substitute.For <IUnitOfWork>();
unitOfWorkSubstitute.CoursesRepository.GetById(course.Id).Returns(course);
var query = new GetCourseQuery(course.Id.Value);
var queryHandler = new GetCourseQueryHandler(unitOfWorkSubstitute);
var coursesQuery = queryHandler.Handle(query);
coursesQuery.Name.Should().Be("Kurs Angielskiego A1");
}
}
public async Task Then_If_There_Is_No_Course_Returns_Null(
GetCourseQuery request,
[Frozen] Mock <IValidator <GetCourseQuery> > mockValidator,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <ICourseService> mockService,
GetCourseQueryHandler handler)
{
//Arrange
validationResult.ValidationDictionary.Clear();
mockValidator.Setup(x => x.ValidateAsync(request)).ReturnsAsync(validationResult);
mockService.Setup(x => x.GetCourse(request.CourseId, request.Lat, request.Lon, request.LocationName, request.ShortlistUserId)).ReturnsAsync((TrainingCourse)null);
//Act
var actual = await handler.Handle(request, CancellationToken.None);
//Assert
mockService.Verify(x => x.GetCourse(request.CourseId, request.Lat, request.Lon, request.LocationName, request.ShortlistUserId), Times.Once);
Assert.IsNull(actual.Course);
Assert.IsNull(actual.ProvidersCount);
Assert.AreEqual(0, actual.ShortlistItemCount);
}
public void Then_Throws_ValidationException_When_Request_Fails_Validation(
GetCourseQuery request,
string propertyName,
[Frozen] Mock <IValidator <GetCourseQuery> > mockValidator,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <ICourseService> mockService,
GetCourseQueryHandler handler)
{
//Arrange
validationResult.AddError(propertyName);
mockValidator
.Setup(validator => validator.ValidateAsync(It.IsAny <GetCourseQuery>()))
.ReturnsAsync(validationResult);
//Act
var act = new Func <Task>(async() => await handler.Handle(request, CancellationToken.None));
//Assert
act.Should().Throw <ValidationException>()
.WithMessage($"*{propertyName}*");
}
public async Task Then_If_The_Query_Is_Valid_The_Service_Is_Called_And_The_Data_Returned(
GetCourseQuery request,
TrainingCourse courseResponse,
[Frozen] Mock <IValidator <GetCourseQuery> > mockValidator,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <ICourseService> mockService,
GetCourseQueryHandler handler)
{
//Arrange
validationResult.ValidationDictionary.Clear();
mockValidator.Setup(x => x.ValidateAsync(request)).ReturnsAsync(validationResult);
mockService.Setup(x => x.GetCourse(request.CourseId, request.Lat, request.Lon, request.LocationName, request.ShortlistUserId)).ReturnsAsync(courseResponse);
//Act
var actual = await handler.Handle(request, CancellationToken.None);
//Assert
mockService.Verify(x => x.GetCourse(request.CourseId, request.Lat, request.Lon, request.LocationName, request.ShortlistUserId), Times.Once);
Assert.IsNotNull(actual);
actual.Course.Should().BeEquivalentTo(courseResponse.Course);
actual.ProvidersCount.Should().BeEquivalentTo(courseResponse.ProvidersCount);
actual.ShortlistItemCount.Should().Be(courseResponse.ShortlistItemCount);
}
