public void NotCallDeleteMethodFromSubjectClassOfStudentsDaysOfWeekRepo_AndCommitMethodFromUoWN_WhenItemFoundIsNull()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
SubjectClassOfStudentsDaysOfWeek expected = null;
mockedSubjectClassOfStudentsDaysOfWeekRepo
.Setup(x => x.GetFirst(It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > >()))
.Returns(expected);
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
() => mockedUnitOfWork.Object);
scheduleService.RemoveSubjectFromSchedule(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>());
mockedSubjectClassOfStudentsDaysOfWeekRepo.Verify(x => x.Delete(It.IsAny <SubjectClassOfStudentsDaysOfWeek>()), Times.Never);
mockedUnitOfWork.Verify(x => x.Commit(), Times.Never);
}
public void ReturnAllDaysOfWeek()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
IEnumerable <DaysOfWeek> actual = new List <DaysOfWeek>()
{
new DaysOfWeek(),
new DaysOfWeek(),
new DaysOfWeek()
};
mockedDaysOfWeekRepo.Setup(x => x.GetAll()).Returns(actual);
var expected = scheduleService.GetAllDaysOfWeek();
CollectionAssert.AreEquivalent(expected, actual);
}
public void Return_EmptyCollection_WhenTeacherDoesNotHaveAssignedProgram()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
mockedUserRepo
.Setup(x => x.GetFirst(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(new User());
mockedSubjectRepo
.Setup(x => x.GetAll(It.IsAny <Expression <Func <Subject, bool> > >(), It.IsAny <Expression <Func <Subject, int> > >()))
.Returns(new List <int>());
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
var result = scheduleService.GetTeacherScheduleForTheDay(It.IsIn <DayOfWeek>(), "NotNullUserName");
Assert.AreEqual(0, result.Count());
}
public void Return_EmptyCollection_AndCallGetFirstMethodFromUserRepoOnce_WhenUserFoundIsNull()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
User expectedReturnFromRepo = null;
mockedUserRepo
.Setup(x => x.GetFirst(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(expectedReturnFromRepo);
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
var result = scheduleService.GetStudentScheduleForTheDay(It.IsIn <DayOfWeek>(), "NotNullUserName");
mockedUserRepo.Verify(x => x.GetFirst(It.IsAny <Expression <Func <User, bool> > >()), Times.Once);
mockedStudentRepo.Verify(x => x.GetFirst(It.IsAny <Expression <Func <Student, bool> > >()), Times.Never);
Assert.AreEqual(0, result.Count());
}
public void Call_SubjectClassOfStudentsDaysOfWeekRepo_GetAllMethodOnce()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
scheduleService.GetClassScheduleForTheDay(It.IsAny <int>(), It.IsAny <int>());
mockedSubjectClassOfStudentsDaysOfWeekRepo.Verify(
x => x.GetAll(
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, ManagingScheduleModel> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[]>()),
Times.Once);
}
public void CallAddMethod_FromSubjectClassOfStudentDaysOfWeekRepo_Once_AndReturnFalse_WhenExceptionIsThrown()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
mockedUnitOfWork.Setup(x => x.Commit()).Throws(new Exception());
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
() => mockedUnitOfWork.Object);
var resultOfAdding = scheduleService.AddSubjectToSchedule(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <DateTime>(), It.IsAny <DateTime>());
mockedSubjectClassOfStudentsDaysOfWeekRepo.Verify(x => x.Add(It.IsAny <SubjectClassOfStudentsDaysOfWeek>()), Times.Once);
Assert.False(resultOfAdding);
}
public ScheduleViewModel(ScheduleDataService scheduleDataServices,
AmbulatoryViewModelFactory ambulatoryViewModelFactory,
ClaimsPrincipal claimsPrincipal)
{
_scheduleDataServices = scheduleDataServices;
_ambulatoryViewModelFactory = ambulatoryViewModelFactory;
_claimsPrincipal = claimsPrincipal;
SelectedDate = new DateTime(2021, 05, 03);
}
public void ReturnCorrectData()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
var mockedSubjectClassOfStudentsDaysOfWeek = new SubjectClassOfStudentsDaysOfWeek()
{
DaysOfWeekId = 1,
DaysOfWeek = new DaysOfWeek(),
ClassOfStudentsId = 1,
SubjectClassOfStudents = new SubjectClassOfStudents()
{
Subject = new Subject()
},
StartHour = DateTime.Now,
EndHour = DateTime.Now
};
var actual = new List <SubjectClassOfStudentsDaysOfWeek>()
{
mockedSubjectClassOfStudentsDaysOfWeek,
mockedSubjectClassOfStudentsDaysOfWeek,
mockedSubjectClassOfStudentsDaysOfWeek
};
mockedSubjectClassOfStudentsDaysOfWeekRepo
.Setup(x => x.GetAll(
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, ManagingScheduleModel> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[]>()))
.Returns((Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > predicate,
Expression <Func <SubjectClassOfStudentsDaysOfWeek, ManagingScheduleModel> > expression,
Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[] include) =>
actual.Where(predicate.Compile()).Select(expression.Compile()));
var expected = scheduleService.GetClassScheduleForTheDay(1, 1);
Assert.AreEqual(actual.Count(), expected.Count());
CollectionAssert.AreNotEquivalent(expected, actual);
}
public ScheduleObjectCollection GetAll()
{
ScheduleObjectCollection schedules;
try
{
schedules = new ScheduleDataService().GetAll();
}
catch (System.Exception exception1)
{
System.Exception innerException = exception1;
throw new System.Exception(MethodBase.GetCurrentMethod().Name, innerException);
}
return(schedules);
}
public RootViewModelFactory(
AmbulatoryViewModelFactory ambulatoryViewModelFactory,
IAuthenticationService <Staff> authenticationService,
ClaimsPrincipal claimsPrincipal,
IGenericRepository <Belay> belayRepository,
IGenericRepository <Patient> patientRepository,
ScheduleDataService scheduleDataServices,
EntryDataService entryDataService)
{
_ambulatoryViewModelFactory = ambulatoryViewModelFactory;
_authenticationService = authenticationService;
_claimsPrincipal = claimsPrincipal;
_belayRepository = belayRepository;
_patientRepository = patientRepository;
_scheduleDataServices = scheduleDataServices;
_entryDataService = entryDataService;
}
public void Call_daysOfWeekRepoGetAll_MethodOnce()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
scheduleService.GetAllDaysOfWeek();
mockedDaysOfWeekRepo.Verify(x => x.GetAll(), Times.Once);
}
public void Throw_ArgumentException_WithMessageContaining_Username_WhenUserNameIsEmptyString()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
Assert.That(
() => scheduleService.GetStudentScheduleForTheDay(It.IsAny <DayOfWeek>(), string.Empty),
Throws.ArgumentException.With.Message.Contain("username"));
}
public void ReturnCorrectlyMappedData()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
var studentUserName = "******";
var user = new User()
{
UserName = studentUserName
};
mockedUserRepo
.Setup(x => x.GetFirst(It.IsAny <Expression <Func <User, bool> > >()))
.Returns(user);
var classOfStudnetsName = "ClassOfStudentsName";
var classOfStudents = new ClassOfStudents()
{
Id = 1,
Name = classOfStudnetsName
};
var student = new Student()
{
ClassOfStudents = classOfStudents,
User = user,
Id = user.Id,
ClassOfStudentsId = classOfStudents.Id
};
mockedStudentRepo
.Setup(x => x.GetFirst(It.IsAny <Expression <Func <Student, bool> > >()))
.Returns(student);
DayOfWeek dayOfWeek = DayOfWeek.Monday;
var day = new DaysOfWeek()
{
Id = 1, Name = dayOfWeek.ToString()
};
var startHour = It.IsAny <DateTime>();
var endHour = It.IsAny <DateTime>();
var subjectName = "test";
var subjectId = 1;
var teacher = new Teacher()
{
User = new User()
{
LastName = "TeacherLastName"
}
};
var subject = new Subject()
{
Name = subjectName,
Teacher = teacher,
Id = subjectId,
ImageUrl = "UrlToTheImage"
};
var subjectsClassOfStudnets = new SubjectClassOfStudents()
{
ClassOfStudentsId = 1,
Subject = subject,
ClassOfStudents = classOfStudents
};
var data = new List <SubjectClassOfStudentsDaysOfWeek>()
{
new SubjectClassOfStudentsDaysOfWeek()
{
SubjectClassOfStudents = subjectsClassOfStudnets,
StartHour = startHour,
EndHour = endHour,
ClassOfStudentsId = 1,
DaysOfWeekId = 1,
SubjectId = 1,
DaysOfWeek = day
}
};
IEnumerable <ScheduleModel> expectedResult = null;
mockedSubjectClassOfStudentsDaysOfWeekRepo
.Setup(
x => x.GetAll(
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, ScheduleModel> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[]>()))
.Returns((Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > predicate,
Expression <Func <SubjectClassOfStudentsDaysOfWeek, ScheduleModel> > expression,
Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[] include) =>
{
expectedResult = data.Where(predicate.Compile()).Select(expression.Compile()).ToList();
return(expectedResult);
});
// ACT
var result = scheduleService.GetStudentScheduleForTheDay(dayOfWeek, studentUserName);
CollectionAssert.AreEquivalent(expectedResult, result);
}
public void Map_DataCorrectly()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedUserRepo = new Mock <IRepository <User> >();
var mockedTeacherRepo = new Mock <IRepository <Teacher> >();
var mockedSubjectClassOfStudentsDaysOfWeekRepo = new Mock <IRepository <SubjectClassOfStudentsDaysOfWeek> >();
var mockedDaysOfWeekRepo = new Mock <IRepository <DaysOfWeek> >();
var mockedStudentRepo = new Mock <IRepository <Student> >();
var mockedUnitOfWork = new Mock <Func <IUnitOfWork> >();
var scheduleService = new ScheduleDataService(
mockedSubjectRepo.Object,
mockedUserRepo.Object,
mockedTeacherRepo.Object,
mockedSubjectClassOfStudentsDaysOfWeekRepo.Object,
mockedDaysOfWeekRepo.Object,
mockedStudentRepo.Object,
mockedUnitOfWork.Object);
var mockedSubjectClassOfStudentsDaysOfWeek = new SubjectClassOfStudentsDaysOfWeek()
{
DaysOfWeekId = 1,
DaysOfWeek = new DaysOfWeek(),
ClassOfStudentsId = 1,
SubjectClassOfStudents = new SubjectClassOfStudents()
{
Subject = new Subject()
},
StartHour = DateTime.Now,
EndHour = DateTime.Now
};
var collection = new List <SubjectClassOfStudentsDaysOfWeek>()
{
mockedSubjectClassOfStudentsDaysOfWeek
};
IEnumerable <ManagingScheduleModel> expected = null;
mockedSubjectClassOfStudentsDaysOfWeekRepo
.Setup(x => x.GetAll(
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, ManagingScheduleModel> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[]>()))
.Returns((Expression <Func <SubjectClassOfStudentsDaysOfWeek, bool> > predicate,
Expression <Func <SubjectClassOfStudentsDaysOfWeek, ManagingScheduleModel> > expression,
Expression <Func <SubjectClassOfStudentsDaysOfWeek, object> >[] include) =>
{
expected = collection.Where(predicate.Compile()).Select(expression.Compile()).ToList();
return(expected);
});
var result = scheduleService.GetClassScheduleForTheDay(1, 1).ToList();
//TODO SHOW TO KIKO
//Assert.AreSame(collection[0].DaysOfWeek, result[0].DaysOfWeek);
//Assert.AreEqual(collection[0].StartHour, result[0].StartHour);
//Assert.AreEqual(collection[0].EndHour, result[0].EndHour);
//Assert.AreSame(collection[0].SubjectClassOfStudents.Subject, result[0].Subject);
CollectionAssert.AreEquivalent(expected, result);
}
