public async Task DeleteCourse_ShouldDeleteCourseCorrectly_IfCourseexist_AndUserIsCreator()
{
Course deletedCourse = null;
var courseRepoBuilder = new CoursesRepositoryBuilder();
courseRepoBuilder.CoursesRepoMock.Setup(r => r.Delete(It.IsAny <Course>()))
.Callback <Course>(c => deletedCourse = c);
var courseRepo = courseRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(null, courseRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
await sut.DeleteCourse("2", user);
Assert.Equal("2", deletedCourse.Id);
courseRepoBuilder.CoursesRepoMock.Verify();
courseRepoBuilder.CoursesRepoMock.Verify(d => d.Delete(It.IsAny <Course>()), Times.Once);
courseRepoBuilder.CoursesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Once);
}
public async Task AddExistCourseTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfDeletableEntityRepository <Course>(new ApplicationDbContext(options.Options));
var userRepository =
new EfDeletableEntityRepository <ApplicationUser>(new ApplicationDbContext(options.Options));
var user = new ApplicationUser
{
FullName = "Test",
};
var course = new Course
{
Title = "test",
};
await userRepository.AddAsync(user);
await userRepository.SaveChangesAsync();
await repository.AddAsync(course);
await repository.SaveChangesAsync();
var coursesService = new CoursesService(repository, userRepository);
coursesService.AddCourseAsync(course.Id, user.Id, 1, 1);
coursesService.AddCourseAsync(course.Id, user.Id, 1, 1);
Assert.Single(user.Courses);
}
public IHttpActionResult CreateCourse(CourseCreator courseCreator)
{
coursesService = new CoursesService();
subjectsService = new SubjectsService();
teachersService = new TeachersService();
subjectToExposeService = new SubjectToExposeService();
courseToExposeService = new CourseToExposeService();
if (courseCreator == null)
{
return(BadRequest());
}
bool exists = false;
exists = coursesService.CheckIfCourseAlreadyExists(courseCreator.Title);
if (exists)
{
return(BadRequest());
}
List <CourseSubject> courseSubjects = coursesService.CreateCourse(courseCreator);
List <SubjectToExpose> subjectsToExpose = new List <SubjectToExpose>();
foreach (CourseSubject courseSubject in courseSubjects)
{
Subject subject = new Subject();
subject = subjectsService.Find(courseSubject.SubjectId);
if (subject == null)
{
return(BadRequest());
}
if (subject.ID == 0)
{
return(BadRequest());
}
Teacher teacher = new Teacher();
teacher = teachersService.GetTeacherNameByID(subject.TeacherId);
if (teacher == null)
{
return(BadRequest());
}
SubjectToExpose subjectToExpose = subjectToExposeService.TrimSubject(subject);
subjectsToExpose.Add(subjectToExpose);
}
CourseToExpose course = courseToExposeService
.TrimSubject(courseSubjects, courseCreator, subjectsToExpose);
return(Created(new Uri(Request.RequestUri + "/" + course.Id), course));
}
public async Task EditCourseTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var courseRepository = new EfDeletableEntityRepository <Course>(new ApplicationDbContext(options.Options));
var mockUserCourseRepository = new Mock <IRepository <UserCourse> >();
var mockConfiguration = new Mock <IConfiguration>();
var mockCategoryService = new Mock <ICategoriesService>();
var store = new Mock <IUserStore <ApplicationUser> >();
var mockUserManager = new Mock <UserManager <ApplicationUser> >(store.Object, null, null, null, null, null, null, null, null);
var service = new CoursesService(courseRepository, mockUserCourseRepository.Object, mockConfiguration.Object, mockCategoryService.Object, mockUserManager.Object);
var coursesToAdd = this.GetCourseData();
foreach (var item in coursesToAdd)
{
await courseRepository.AddAsync(item);
await courseRepository.SaveChangesAsync();
}
await service.EditCourse("1", "EditedName", "1", "Expert", "stillnothing", "NewDescription", "User1");
var course = courseRepository.All().FirstOrDefault(x => x.Id == "1");
Assert.Equal("EditedName", course.Name);
Assert.Equal("Expert", course.Difficulty);
Assert.Equal("stillnothing", course.ThumbnailUrl);
Assert.Equal("User1", course.UserId);
}
public async Task DeleteCourseTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var courseRepository = new EfDeletableEntityRepository <Course>(new ApplicationDbContext(options.Options));
var mockUserCourseRepository = new Mock <IRepository <UserCourse> >();
var mockConfiguration = new Mock <IConfiguration>();
var mockCategoryService = new Mock <ICategoriesService>();
var store = new Mock <IUserStore <ApplicationUser> >();
var mockUserManager = new Mock <UserManager <ApplicationUser> >(store.Object, null, null, null, null, null, null, null, null);
var service = new CoursesService(courseRepository, mockUserCourseRepository.Object, mockConfiguration.Object, mockCategoryService.Object, mockUserManager.Object);
var coursesToAdd = this.GetCourseData();
foreach (var item in coursesToAdd)
{
await courseRepository.AddAsync(item);
await courseRepository.SaveChangesAsync();
}
await service.DeleteCourse("1", "User1");
await service.DeleteCourse("2", "User2");
var courses = courseRepository.All();
Assert.Equal(3, courses.Count());
}
public List <MyCourseFromListDTO> CoursesBySport(string login, string sport)
{
CoursesService service = new CoursesService(services);
List <MyCourseFromListDTO> result = service.GetCoursesByUserAndSport(login, sport);
return(result);
}
public async Task GetCourseTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var courseRepository = new EfDeletableEntityRepository <Course>(new ApplicationDbContext(options.Options));
var userCourseRepository = new EfRepository <UserCourse>(new ApplicationDbContext(options.Options));
var mockConfiguration = new Mock <IConfiguration>();
var mockCategoryService = new Mock <ICategoriesService>();
var store = new Mock <IUserStore <ApplicationUser> >();
var mockUserManager = new Mock <UserManager <ApplicationUser> >(store.Object, null, null, null, null, null, null, null, null);
var service = new CoursesService(courseRepository, userCourseRepository, mockConfiguration.Object, mockCategoryService.Object, mockUserManager.Object);
AutoMapperConfig.RegisterMappings(typeof(EnrolledCourseViewModel).Assembly);
var coursesToAdd = this.GetCourseData();
foreach (var item in coursesToAdd)
{
await courseRepository.AddAsync(item);
await courseRepository.SaveChangesAsync();
}
var course = service.GetCourse <EnrolledCourseViewModel>("1");
Assert.Equal("Course1", course.Name);
}
protected void Page_Load(object sender, EventArgs e)
{
var coursesID = Request.QueryString["ID"];
if (!IsPostBack && coursesID == null)
{
ddlDepartmentID.DataSource = Utility.Utility.GetAllDepartments();
ddlDepartmentID.DataTextField = "Name";
ddlDepartmentID.DataValueField = "ID";
ddlDepartmentID.DataBind();
}
if (!IsPostBack && coursesID != null)
{
ddlDepartmentID.DataSource = Utility.Utility.GetAllDepartments();
ddlDepartmentID.DataTextField = "Name";
ddlDepartmentID.DataValueField = "ID";
ddlDepartmentID.DataBind();
CoursesService coursesService = new CoursesService();
var courses = coursesService.GetOneCourses(Convert.ToInt32(coursesID));
courses.ID = Convert.ToInt32(coursesID);
txtTitle.Text = courses.Title.Trim();
txtCredits.Text = courses.Credits.ToString();
ddlDepartmentID.SelectedValue = courses.DepartmentID.ToString();
txtCreatedDate.Text = courses.CreatedDate.ToString();
txtCreatedBy.Text = courses.CreatedBy.Trim();
txtUpdatedDate.Text = courses.UpdatedDate.ToString();
txtUpdatedBy.Text = courses.UpdatedBy.Trim();
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
var coursesID = Request.QueryString["ID"];
if (coursesID == null)
{
Contoso.Models.Courses courses = new Contoso.Models.Courses();
courses.Title = txtTitle.Text;
courses.Credits = Convert.ToInt32(txtCredits.Text);
courses.DepartmentID = Convert.ToInt32(ddlDepartmentID.SelectedValue);
courses.CreatedDate = Convert.ToDateTime(txtCreatedDate.Text);
courses.CreatedBy = txtCreatedBy.Text;
courses.UpdatedDate = Convert.ToDateTime(txtUpdatedDate.Text);
courses.UpdatedBy = txtUpdatedBy.Text;
CoursesService coursesService = new CoursesService();
coursesService.AddCourses(courses);
}
if (coursesID != null)
{
Contoso.Models.Courses courses = new Models.Courses();
courses.ID = Convert.ToInt32(coursesID);
courses.Title = txtTitle.Text;
courses.Credits = Convert.ToInt32(txtCredits.Text);
courses.DepartmentID = Convert.ToInt32(ddlDepartmentID.SelectedValue);
courses.CreatedDate = Convert.ToDateTime(txtCreatedDate.Text);
courses.CreatedBy = txtCreatedBy.Text;
courses.UpdatedDate = Convert.ToDateTime(txtUpdatedDate.Text);
courses.UpdatedBy = txtUpdatedBy.Text;
CoursesService coursesService = new CoursesService();
coursesService.UpdateCourses(courses);
}
}
public void LeaveCourse(int id)
{
string login = HttpContext.Session.GetString("User_Login");
CoursesService service = new CoursesService(services);
service.LeaveCourse(login, id);
}
public void EditCourse(CourseDTO course)
{
string login = HttpContext.Session.GetString("User_Login");
CoursesService service = new CoursesService(services);
service.EditCourse(course, login);
}
public void DeleteCourse(int id)
{
string login = HttpContext.Session.GetString("User_Login");
CoursesService service = new CoursesService(services);
service.DeleteCourse(id, login);
}
public async Task AddUserToCourse_ShouldNotAddNew_CourseUser_WhenMaxCountParticipantsIsFully()
{
var coursesRepoBuilder = new CoursesRepositoryBuilder();
var courseRepo = coursesRepoBuilder
.WithAll()
.Build();
var coursesUsersRepoBuilder = new CoursesUsersRepositoryBuilder();
var courseUserRepo = coursesUsersRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(courseUserRepo, courseRepo, null, Mapper);
var user = new GoUser {
Id = "7"
};
var user1 = new GoUser {
Id = "8"
};
await sut.AddUserToCourse("1", user);
await sut.AddUserToCourse("1", user1);
coursesUsersRepoBuilder.CoursesUsersRepoMock.Verify(r => r.AddAsync(It.IsAny <CoursesUsers>()), Times.Exactly(1));
coursesUsersRepoBuilder.CoursesUsersRepoMock.Verify(r => r.SaveChangesAsync(), Times.Exactly(1));
}
public List <CoachCourseFromListDTO> Courses(string login)
{
CoursesService service = new CoursesService(services);
List <CoachCourseFromListDTO> result = service.GetCoursesByCoach(login);
return(result);
}
public async Task DeleteCourse_ShouldNotDeleteCourse_WhenCourseNotExist()
{
Course deletedCourse = null;
var courseRepoBuilder = new CoursesRepositoryBuilder();
courseRepoBuilder.CoursesRepoMock.Setup(r => r.Delete(It.IsAny <Course>()))
.Callback <Course>(c => deletedCourse = c);
var courseRepo = courseRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(null, courseRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
await sut.DeleteCourse("7", user);
Assert.Null(deletedCourse);
courseRepoBuilder.CoursesRepoMock.Verify();
courseRepoBuilder.CoursesRepoMock.Verify(d => d.Delete(It.IsAny <Course>()), Times.Exactly(0));
courseRepoBuilder.CoursesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Exactly(0));
}
public HomeController()
{
// Initialize the services
CoursesService = new CoursesService();
InstructorCourseAssocService = new InstructorCourseAssocService();
StudentCourseAssocService = new StudentCourseAssocService();
}
public async Task ShouldReturnFalseIfThereIsNotAvailability()
{
//ARRANGE
const int courseId = 1;
var session = new Session
{
CourseId = 1,
MaxCapacity = 2,
NumberOfStudents = 1
};
_sessionRepository.Setup(s => s.FirstOrDefaultAsync(It.IsAny <Expression <Func <Session, bool> > >())).Returns(Task.FromResult(session));
var sut = new CoursesService(_courseRepository.Object,
_sessionRepository.Object,
_ssRepository.Object,
_studentRepository.Object);
//ACT
var res = await sut.CheckAvailabilityAsync(courseId);
//ASSERT
Assert.False(res);
}
public object FindCourses(
string sport,
string name,
string coach,
int?rate_min,
int?rate_max,
int?members_min,
int?members_max,
int page,
int page_size,
SortCourses?sort,
bool desc = false)
{
CoursesService service = new CoursesService(services);
return(service.FindCourses(
sport,
name,
coach,
rate_min,
rate_max,
members_min,
members_max,
page,
page_size,
sort,
desc));
}
public void GetAllParticipants_ShouldThrow_IfUserIsNotCreator()
{
var coursesRepoBuilder = new CoursesRepositoryBuilder();
var courseRepo = coursesRepoBuilder
.WithAll()
.Build();
var coursesUsersRepoBuilder = new CoursesUsersRepositoryBuilder();
var coursUserRepo = coursesUsersRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(coursUserRepo, courseRepo, null, Mapper);
var user = new GoUser {
Id = "9"
};
var ex = Assert.Throws <ArgumentException>(() => sut.GetAllParticipants("1", user));
Assert.Equal("You can not add results!", ex.Message);
coursesRepoBuilder.CoursesRepoMock.Verify();
coursesUsersRepoBuilder.CoursesUsersRepoMock.Verify();
}
public async Task EditCourse_ShouldNotEditCourseIf_UserIsNotCreator()
{
var user = new GoUser {
Id = "2"
};
var coursesRepoBuilder = new CoursesRepositoryBuilder();
var courseRepo = coursesRepoBuilder
.WithAll()
.Build();
var sut = new CoursesService(null, courseRepo, null, Mapper);
var editCourseViewModel = new EditCourseViewModel
{
Id = "2",
Image = SetupFileMock().Object,
Title = "Edit",
Description = "Brr",
MaxCountParticipants = 7,
StartDate = DateTime.Now.AddDays(2),
DurationOfDays = 5,
Status = Status.Practically,
Category = Category.Other
};
await sut.EditCourse(editCourseViewModel, user);
coursesRepoBuilder.CoursesRepoMock.Verify(d => d.SaveChangesAsync(), Times.Exactly(0));
}
public CoursesController(CoursesService courseSvc,
UserManager <EtoUser> usrMgr,
IAuthorizationService authService)
{
coursesService = courseSvc;
userManager = usrMgr;
authorizationService = authService;
}
public InstituteViewModel(Institute institute, CoursesService coursesService, Navigator navigator, Func <Course, CourseViewModel> courseViewModelFactory)
{
CoursesService = coursesService;
AppNavigator = navigator;
CourseViewModelFactory = courseViewModelFactory;
InitializeViewModelFromModel(institute);
}
public StudentsListViewModel(INavigation navi, _Class _class, Page page)
{
_page = page;
Navigation = navi;
cService = new CoursesService();
GetStudentsListAsync(_class);
Refresh = new Command(() => GetStudentsListAsync(_class, true));
}
public CoursesServiceDetailsTests()
{
AutoMapperConfig.RegisterMappings(typeof(ErrorViewModel).GetTypeInfo().Assembly);
this.db = new CoursesP2PDbContext(MemoryDatabase.OptionBuilder());
this.coursesService = new CoursesService(this.db);
}
public CoursesServiceTest()
{
this.context = BaseServiceTests.CreateDbContext();
var repository = new EfDeletableEntityRepository <Course>(this.context);
this.service = new CoursesService(repository);
this.mockService = new Mock <ICoursesService>();
}
public CourseListViewModel(INavigation navi, Page page)
{
cService = new CoursesService();
_page = page;
Navigation = navi;
GetCoursesAsync();
ShowCourse = new Command(async() => await Navigation.PushAsync(new CourseDetailsPage(Navigation, SelectedCourse)));
Refresh = new Command(() => GetCoursesAsync(true));
}
public CoursesController()
{
// Initialize the services
CoursesService = new CoursesService();
ListDataService = new ListDataService();
UsersService = new UsersService();
InstructorCourseAssocService = new InstructorCourseAssocService();
StudentCourseAssocService = new StudentCourseAssocService();
}
public CourseViewModel(Course course, Navigator navigator, CoursesService service, TestsService testsService, Func <Test, TestsListItemViewModel> testViewModelFactory)
{
Service = service;
TestsService = testsService;
AppNavigator = navigator;
TestViewModelFactory = testViewModelFactory;
InitializeViewModelFromModel(course);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
CoursesService coursesService = new CoursesService();
repeaterCourses.DataSource = coursesService.GetAllCourses();
repeaterCourses.DataBind();
}
}
public CoursesController(CoursesRepository productRepo, CoursesService productService, IMapper mapper, FileHelper fileHelper, PaginatedMetaService paginatedMetaService, FacultyRepository facultyRepository)
{
_productRepo = productRepo;
_productService = productService;
_mapper = mapper;
_fileHelper = fileHelper;
_paginatedMetaService = paginatedMetaService;
_facultyRepository = facultyRepository;
}
