public bool AddClass(string name, IEnumerable <string> subjecIds)
{
Guard.WhenArgument(name, "name").IsNullOrEmpty().Throw();
Guard.WhenArgument(subjecIds, "subjecIds").IsNull().Throw();
if (this.IsClassNameUnique(name))
{
return(false);
}
else
{
using (var uow = this.unitOfWork())
{
var classOfStudents = new ClassOfStudents()
{
Name = name
};
// adding subjects for the class
foreach (var subject in subjecIds)
{
this.subjectClassOfStudnetsrepo.Add(new SubjectClassOfStudents()
{
SubjectId = int.Parse(subject),
ClassOfStudents = classOfStudents
});
}
this.classOfStudentsRepo.Add(classOfStudents);
return(uow.Commit());
}
}
}
public void ReturnEmptyCollection_WhenThereAreNotSubjectsAvaiableToAssignForThisClass()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
var classId = 1;
var classOfStudents = new ClassOfStudents()
{
Id = classId, Name = "classOfStudents"
};
var subject = new Subject()
{
Id = 1, Name = "Subj1"
};
var subjects = new List <Subject>()
{
subject
};
var data = new List <SubjectClassOfStudents>();
{
new SubjectClassOfStudents()
{
SubjectId = subject.Id, ClassOfStudentsId = classId
};
};
subject.SubjecClassOfStudents = data;
IEnumerable <int> alreadyassigndedSubjectIds = null;
mockedSubjClassRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <SubjectClassOfStudents, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, int> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, object> >[]>()))
.Returns((Expression <Func <SubjectClassOfStudents, bool> > predicate,
Expression <Func <SubjectClassOfStudents, int> > select) =>
alreadyassigndedSubjectIds = data.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
IEnumerable <SubjectBasicInfoModel> expected = null;
mockedSubjectRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <Subject, bool> > >(),
It.IsAny <Expression <Func <Subject, SubjectBasicInfoModel> > >()))
.Returns((Expression <Func <Subject, bool> > predicate,
Expression <Func <Subject, SubjectBasicInfoModel> > select) =>
expected = subjects.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
var result = subjectsManagementService.GetSubjectsNotYetAssignedToTheClass(classId);
CollectionAssert.AreEquivalent(expected, result);
Assert.AreEqual(0, result.Count());
}
public static void MainTest(Random rng)
{
// Create a ClassOfStudents
var filename = @"myClassOfStudents.txt";
var myClassOfStudents = ClassOfStudents.CreateFromFile(filename);
myClassOfStudents.FirstBeforeLast();
}
public void Call_GetAllMethod_FromSubjectsClassOfStudentsRepo_Once_AndReturnCorrectResult()
{
var mockedClassOfStudentsRepo = new Mock <IRepository <ClassOfStudents> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var mockedSubjectClassOfStudentsRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var service = new ClassOfStudentsManagementService(mockedClassOfStudentsRepo.Object, mockedSubjectClassOfStudentsRepo.Object, () => mockedUnitOfWork.Object);
var subjectId = 1;
var firstClassOofStudents = new ClassOfStudents()
{
Id = 1
};
var secondClassOfStudents = new ClassOfStudents()
{
Id = 2
};
var thirdClassOfStudents = new ClassOfStudents()
{
Id = 3
};
var dataToFilter = new List <SubjectClassOfStudents>()
{
new SubjectClassOfStudents()
{
SubjectId = 1, ClassOfStudents = firstClassOofStudents
},
new SubjectClassOfStudents()
{
SubjectId = 1, ClassOfStudents = secondClassOfStudents
},
new SubjectClassOfStudents()
{
SubjectId = 1, ClassOfStudents = thirdClassOfStudents
},
};
IEnumerable <ClassOfStudents> expected = null;
mockedSubjectClassOfStudentsRepo.Setup(x => x.GetAll(It.IsAny <Expression <Func <SubjectClassOfStudents, bool> > >(), It.IsAny <Expression <Func <SubjectClassOfStudents, ClassOfStudents> > >()))
.Returns(
(Expression <Func <SubjectClassOfStudents, bool> > predicate,
Expression <Func <SubjectClassOfStudents, ClassOfStudents> > select) =>
expected = dataToFilter
.Where(predicate.Compile())
.Select(select.Compile()));
var result = service.GetAllClassesWithSpecifiedSubject(subjectId);
mockedSubjectClassOfStudentsRepo
.Verify(x => x.GetAll(It.IsAny <Expression <Func <SubjectClassOfStudents, bool> > >(), It.IsAny <Expression <Func <SubjectClassOfStudents, ClassOfStudents> > >()), Times.Once);
CollectionAssert.AreEquivalent(expected, result);
}
public static ClassOfStudents ToClassOfStudents <T>(this IEnumerable <T> collection)
where T : Student
{
var output = new ClassOfStudents();
foreach (dynamic student in collection)
{
output.AddStudent(student);
}
return(output);
}
public static void TimedEventTest()
{
var timer = new Timer(5);
var myStudents = new ClassOfStudents();
// Student has a constuctor for testing
// subscribing to the testing event TimedEvent
// printing first and last name on event
myStudents.AddStudent(new Student("1", "1", timer));
myStudents.AddStudent(new Student("2", "2"));
myStudents.AddStudent(new Student("3", "3", timer));
timer.Run();
}
public static void TimedEventTest()
{
var timer = new Timer(5);
var myStudents = new ClassOfStudents();
// Student has a constuctor for testing
// subscribing to the testing event TimedEvent
// printing first and last name on event
myStudents.AddStudent(new Student("1", "1", timer));
myStudents.AddStudent(new Student("2", "2"));
myStudents.AddStudent(new Student("3", "3", timer));
timer.Run();
}
static void Main()
{
Student marko = new Student("Marko Ivanov", "015");
Student petkan = new Student("Petkan Ivanov", "91");
Student dragan = new Student("Dragan Ivanov", "015");
List<Student> students = new List<Student>(){marko, petkan, dragan};
Discipline biology = new Discipline("Biology", 12, 12);
Discipline chemistry = new Discipline("Chemistry", 15, 12);
Discipline math = new Discipline("Math", 150, 100);
List<Discipline> disciplines=new List<Discipline>(){biology, chemistry,math};
Teacher petkov = new Teacher("Georgi Dimitrov", disciplines);
List<Teacher> teachers = new List<Teacher>() { petkov };
ClassOfStudents classA = new ClassOfStudents("11A", teachers, students);
Console.WriteLine("The teacher of {0} of {1} is {2}", disciplines[0].Name,
classA.ClassIdentifier,teachers[0].Name);
}
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 RemoveClass(ClassOfStudents @class)
{
this.Classes.Remove(@class);
}
public void AddClass(ClassOfStudents @class)
{
this.Classes.Add(@class);
}
