public async Task <IActionResult> Get()
{
var query = new GetCoursesQuery();
var result = await mediator.Send(query);
return(FromPresenter(new GetCoursesPresenter(result)));
}
public async Task <ActionResult <IEnumerable <CourseResponse> > > GetCourses()
{
var query = new GetCoursesQuery();
var courses = await _mediator.Send(query);
return(Ok(courses));
}
public void Arrange()
{
_expectedCourses = new List <Course>
{
new Course(new Domain.Entities.Course
{
CourseId = "1",
Title = "Course 1",
Level = 1
}),
new Course(new Domain.Entities.Course
{
CourseId = "2",
Title = "Course 2",
Level = 2
}),
new Course(new Domain.Entities.Course
{
CourseId = "3",
Title = "Course 3",
Level = 3
})
};
_service = new Mock <ICourseService>();
_service.Setup(s => s.GetCourses()).ReturnsAsync(_expectedCourses);
_query = new GetCoursesQuery();
_handler = new GetCoursesQueryHandler(_service.Object);
}
public async Task <IEnumerable <CourseViewModel> > GetCourses()
{
var query = new GetCoursesQuery();
var courses = await this._bus.SendCommand <IEnumerable <Course> >(query);
return(this._mapper.Map <IEnumerable <CourseViewModel> >(courses));
}
public async Task Then_The_Service_Is_Called_And_The_Data_Returned(
GetCoursesQuery request,
TrainingCourses courseResponse,
[Frozen] Mock <ICourseService> mockService,
GetCoursesQueryHandler handler)
{
//Arrange
request.Keyword = null;
request.RouteIds = null;
request.Levels = null;
request.ShortlistUserId = null;
mockService.Setup(x => x.GetCourses(null, null, null, OrderBy.None, null)).ReturnsAsync(courseResponse);
//Act
var actual = await handler.Handle(request, CancellationToken.None);
//Assert
mockService.Verify(x => x.GetCourses(null, null, null, OrderBy.None, null), Times.Once);
Assert.IsNotNull(actual);
actual.Courses.Should().BeEquivalentTo(courseResponse.Courses);
actual.Sectors.Should().BeEquivalentTo(courseResponse.Sectors);
actual.TotalFiltered.Should().Be(courseResponse.TotalFiltered);
actual.Total.Should().Be(courseResponse.Total);
actual.ShortlistItemCount.Should().Be(courseResponse.ShortlistItemCount);
}
public async Task <List <GetCoursesQueryModel> > Handle(GetCoursesQuery request, CancellationToken cancellationToken)
{
var courses = await _readModelRepository.All <CourseReadModel>();
return(courses.Select(x => new GetCoursesQueryModel
{
Id = x.Id,
Number = x.Number,
Title = x.Title,
Credits = x.Credits,
Department = x.Department
}).ToList());
}
public async Task Then_Gets_Courses_From_Service(
GetCoursesQuery query,
CourseList coursesFromService,
[Frozen] Mock <ICourseService> mockService,
GetCoursesQueryHandler handler)
{
mockService
.Setup(service => service.GetCourses())
.ReturnsAsync(coursesFromService);
var result = await handler.Handle(query, CancellationToken.None);
result.Courses.Should().BeEquivalentTo(coursesFromService.Courses);
}
public async Task <IReadOnlyList <GetCoursesViewModel> > Handle(GetCoursesQuery request, CancellationToken cancellationToken)
{
return(await context.Course
.AsNoTracking()
.Where(x => x.IsActive == true)
.Select(x => new GetCoursesViewModel
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
Credits = x.Credits
})
.ToListAsync(cancellationToken));
}
public async Task Then_Keywords_And_Levels_And_Sectors_Are_Passed_To_The_Service(
GetCoursesQuery request,
TrainingCourses courseResponse,
[Frozen] Mock <ICourseService> mockService,
GetCoursesQueryHandler handler)
{
//Arrange
mockService.Setup(x => x.GetCourses(request.Keyword, request.RouteIds, request.Levels, OrderBy.None, request.ShortlistUserId)).ReturnsAsync(courseResponse);
//Act
var actual = await handler.Handle(request, CancellationToken.None);
//Assert
mockService.Verify(x => x.GetCourses(request.Keyword, request.RouteIds, request.Levels, OrderBy.None, request.ShortlistUserId), Times.Once);
Assert.IsNotNull(actual);
}
public async Task It_Returns_A_List_Of_Student_Dtos()
{
repositorySpy.Courses.Add(new CourseDto
{
Id = Guid.NewGuid(),
Title = "Philosophy",
Credits = 1,
});
var query = new GetCoursesQuery();
var result = await handler.Handle(query, new CancellationToken());
Assert.True(result.IsSuccess);
Assert.IsType <List <CourseDto> >(result.Value);
Assert.Same(repositorySpy.Courses, result.Value);
}
public async Task GetCoursesTest_Should_Return_List()
{
//Arrange
var request = new GetCoursesQuery();
var handler = new GetCoursesHandler(_mapper, _fakeRepository);
//Act
var courses = await handler.Handle(request, new CancellationToken());
//Assert
var course = courses.FirstOrDefault(x => x.Id == 1);
Assert.AreEqual(courses.Count(), 2);
Assert.AreEqual(course.Id, 1);
Assert.AreEqual(course.Price, 5000);
}
public async Task Should_return_filter_courses()
{
var createCourseCommand = new CreateCourseCommand()
{
Id = Guid.NewGuid(),
Code = 10,
Name = "Course 1",
Description = "Test"
};
var createCourseCommandHandler = new CreateCourseCommandHandler(this.autoMapper, this.context);
var result = await createCourseCommandHandler.Handle(createCourseCommand, CancellationToken.None);
result.ShouldBe(true);
createCourseCommand.Id = Guid.NewGuid();
createCourseCommand.Code = 2;
createCourseCommand.Name = "Test 2";
result = await createCourseCommandHandler.Handle(createCourseCommand, CancellationToken.None);
result.ShouldBe(true);
var getCoursesQuery = new GetCoursesQuery()
{
FilterByName = "est"
};
var getCoursesQueryHandler = new GetCoursesQueryHandler(this.autoMapper, this.context);
var list = await getCoursesQueryHandler.Handle(getCoursesQuery, CancellationToken.None);
list.Where(c => c.Code == createCourseCommand.Code).Count().ShouldBe(1);
getCoursesQuery = new GetCoursesQuery()
{
FilterByName = ""
};
getCoursesQueryHandler = new GetCoursesQueryHandler(this.autoMapper, this.context);
list = await getCoursesQueryHandler.Handle(getCoursesQuery, CancellationToken.None);
list.Where(c => c.Code == 10 || c.Code == 2).Count().ShouldBe(2);
}
public async Task DeleteCourseTest_And_Check_Collection_Should_Return_Id()
{
//Arrange
var request = new DeleteCourseCommand(1);
var handler = new DeleteCourseHandler(_fakeRepository);
var getRequest = new GetCoursesQuery();
var getHandler = new GetCoursesHandler(_mapper, _fakeRepository);
//Act
var id = await handler.Handle(request, new CancellationToken());
var courses = await getHandler.Handle(getRequest, new CancellationToken());
//Assert
Assert.AreEqual(id, 1);
Assert.AreEqual(courses.Count(), 1);
}
public async Task <List <CourseDetailsDto> > Handle(GetCoursesQuery request, CancellationToken cancellationToken)
{
var courses = await _courseRepository.GetAll();
var coursesStatistics = await _reportingRepository.GetAll();
var courseDetailsList = from c in courses
join s in coursesStatistics on c.Id equals s.CourseId
select new CourseDetailsDto
{
Id = c.Id,
Name = c.Name,
Capacity = c.Capacity,
NumberOfStudents = c.Students.Count,
MinimumStudentAge = s.MinimumStudentAge,
MaximumStudentAge = s.MaximumStudentAge,
AverageStudentAge = s.AverageStudentAge
};
return(courseDetailsList.ToList());
}
public async Task <List <StudyCourseListItemVo> > Handle(GetCoursesQuery message, CancellationToken cancellationToken)
{
List <StudyCourseListItemVo> objs = await studyCourseRepository.GetCourses();
return(objs);
}
public Task <IEnumerable <Course> > Handle(GetCoursesQuery request, CancellationToken cancellationToken)
{
var courses = this._courseRepository.GetCourses();
return(Task.FromResult(courses));
}
public async Task <Result <List <CourseDto> > > Handle(GetCoursesQuery request, CancellationToken cancellationToken)
{
return(Result.Ok(await repository.Get()));
}
public async Task <IActionResult> Get([FromQuery] GetCoursesQuery query)
{
return(Ok(await Mediator.Send(query)));
}
public async Task <IEnumerable <CourseResponse> > Handle(GetCoursesQuery query, CancellationToken token)
{
var course = await _repository.GetCourses();
return(_mapper.Map <IEnumerable <CourseResponse> >(course));
}
public async Task <IActionResult> GetCourses([FromQuery] GetCoursesQuery query)
{
var result = await _mediator.Send(query);
return(Ok(result));
}
public Task <List <Course> > Handle(GetCoursesQuery request, CancellationToken cancellationToken)
{
return(_courseRepository.GetAll());
}
