private void CreatePreKClass(EllCoach coach)
{
int schoolYear = DateTime.Now.Year;
DateTime testSessionDate = new DateTime(schoolYear, 10, 1);
DateTime testResultDate = testSessionDate.AddDays(14);
Department department = Department.EarlyChildhood;
Term term = CreateTerm(SchoolTerm.Fall, schoolYear);
terms.Add(term);
Course course = new Course("PreKindergarten General Education", department);
GradeCourse gradeCourse = new GradeCourse(course, SchoolGrade.PreKindergarten);
TermCourse termCourse = new TermCourse(term, gradeCourse);
Instructor instructor = personCreator.CreatePerson <Instructor>();
instructor.Department = department;
List <Assistant> assistants = personCreator.CreatePeople <Assistant>(2);
List <Student> students = personCreator.CreateStudents(20, schoolYear - 4);
SchoolClass schoolClass = new SchoolClass("Section A");
classAssigner.AssignClass(schoolClass, instructor, assistants, coach, students, termCourse);
Test widaTest = testBuilder.Build();
TestSession session = new TestSession("Fall Test Session 1", testSessionDate, widaTest);
courseManager.AddTestSession(session, schoolClass.CourseAssignment);
students.ForEach(student => widaTest.Sections.ForEach(section => testAssigner.AssignTest(student.Enrollments[0], session, ((IWidaTestBuilder)testBuilder).BuildResult(section, testResultDate))));
classes.Add(schoolClass);
}
void CreatePreKClasses()
{
EllCoach coach = personCreator.CreatePerson <EllCoach>();
for (int i = 0; i < 4; i++)
{
CreatePreKClass(coach);
}
}
public void Map_MapsEllCoach()
{
//Given
Instructor instructor1 = new Instructor()
{
FirstName = "instructor1First",
LastName = "instructor1Last",
Gender = Gender.Male,
Email = "*****@*****.**"
};
Instructor instructor2 = new Instructor()
{
FirstName = "instructor2First",
LastName = "instructor2Last",
Gender = Gender.Male,
Email = "*****@*****.**"
};
EllCoach coach = new EllCoach()
{
FirstName = "coachFirst",
LastName = "coachLast",
Gender = Gender.Male,
Email = "*****@*****.**"
};
coach.Instructors.Add(instructor1);
coach.Instructors.Add(instructor2);
//When
EllCoachDto dto = GetMapped <EllCoachDto, EllCoach>(coach);
//Then
Assert.Equal(coach.Id.ToString(), dto.Id);
Assert.Equal(coach.FirstName, dto.FirstName);
Assert.Equal(coach.LastName, dto.LastName);
Assert.Equal(coach.Email, dto.Email);
Assert.Equal(coach.Gender, dto.Gender);
Assert.Equal(DataAccessConstants.noSqlEllCoachType, dto.Type);
Assert.Equal(DataAccessConstants.noSqlEllCoachVersion, dto.Version);
Assert.Equal(2, dto.Instructors.Count);
Assert.Equal(instructor1.Id.ToString(), dto.Instructors[0].Id);
// Assert.Equal(instructor1.FirstName, dto.Instructors[0].FirstName);
// Assert.Equal(instructor1.LastName, dto.Instructors[0].LastName);
Assert.Equal(instructor1.Email, dto.Instructors[0].Email);
// Assert.Equal(instructor1.Gender, dto.Instructors[0].Gender);
// Assert.Equal(instructor1.Department, dto.Instructors[0].Department);
Assert.Equal(instructor2.Id.ToString(), dto.Instructors[1].Id);
// Assert.Equal(instructor2.FirstName, dto.Instructors[1].FirstName);
// Assert.Equal(instructor2.LastName, dto.Instructors[1].LastName);
Assert.Equal(instructor2.Email, dto.Instructors[1].Email);
// Assert.Equal(instructor2.Gender, dto.Instructors[1].Gender);
// Assert.Equal(instructor2.Department, dto.Instructors[1].Department);
Assert.All(dto.Instructors, instructor => Assert.Equal(DataAccessConstants.noSqlInstructorShortType, instructor.Type));
Assert.All(dto.Instructors, instructor => Assert.Equal(DataAccessConstants.noSqlInstructorShortVersion, instructor.Version));
}
public void AddCoach_AddsCoachToInstructorAndInstructorToCoach()
{
//Given
InstructorManager manager = new InstructorManager();
Instructor instructor = new Instructor();
EllCoach coach = new EllCoach();
//When
manager.AddCoach(coach, instructor);
//Then
Assert.Equal(coach, instructor.EllCoach);
Assert.Contains(instructor, coach.Instructors);
}
public void ExtractEllCoaches_ReturnsUniqueEllCoaches()
{
//Given
FacultyExtractor extractor = new FacultyExtractor();
EllCoach coach1 = new EllCoach();
EllCoach coach2 = new EllCoach();
SchoolClass schoolClass1 = new SchoolClass()
{
CourseAssignment = new CourseAssignment()
{
Instructor = new Instructor()
{
EllCoach = coach1
}
}
};
SchoolClass schoolClass2 = new SchoolClass()
{
CourseAssignment = new CourseAssignment()
{
Instructor = new Instructor()
{
EllCoach = coach2
}
}
};
SchoolClass schoolClass3 = new SchoolClass()
{
CourseAssignment = new CourseAssignment()
{
Instructor = new Instructor()
{
EllCoach = coach2
}
}
};
List <SchoolClass> schoolClasses = new List <SchoolClass>()
{
schoolClass1, schoolClass2, schoolClass3
};
//When
List <EllCoach> ellCoaches = extractor.ExtractEllCoaches(schoolClasses);
//Then
Assert.Equal(2, ellCoaches.Count);
Assert.Contains(coach1, ellCoaches);
Assert.Contains(coach2, ellCoaches);
}
public void AssignClass_AssignsAllClassMembers()
{
//Given
ClassAssigner builder = new ClassAssigner(new InstructorManager(), new CourseManager());
SchoolClass schoolClass = new SchoolClass();
Instructor instructor = new Instructor();
List <Assistant> assistants = new List <Assistant>()
{
new Assistant(), new Assistant()
};
EllCoach coach = new EllCoach();
List <Student> students = new List <Student>()
{
new Student(), new Student(), new Student()
};
TermCourse termCourse = new TermCourse();
//When
builder.AssignClass(schoolClass, instructor, assistants, coach, students, termCourse);
//Then
Assert.Equal(instructor, schoolClass.CourseAssignment.Instructor);
Assert.Equal(termCourse, schoolClass.CourseAssignment.TermCourse);
Assert.Equal(students, schoolClass.Students);
Assert.NotEmpty(schoolClass.Students);
Assert.All(schoolClass.Students, student => Assert.Equal(schoolClass, student.Class));
Assert.All(schoolClass.Students, student => Assert.NotEmpty(student.Enrollments));
Assert.All(schoolClass.Students, student => Assert.NotEmpty(student.Enrollments));
Assert.All(schoolClass.Students, student => Assert.All(student.Enrollments, enrollment => Assert.Equal(student, enrollment.Student)));
Assert.NotEmpty(schoolClass.CourseAssignment.Instructor.Assistants);
Assert.All(assistants, assistant => Assert.Equal(instructor, assistant.Instructor));
Assert.NotEmpty(instructor.Assistants);
Assert.All(instructor.Assistants, assistant => Assert.Contains(assistant, instructor.Assistants));
Assert.Equal(coach, instructor.EllCoach);
Assert.Contains(instructor, coach.Instructors);
}
public void Map_MapsInstructor()
{
//Given
Instructor instructor = new Instructor()
{
FirstName = "instructorFirst",
LastName = "instructorLast",
Gender = Gender.Female,
Email = "*****@*****.**"
};
EllCoach coach = new EllCoach()
{
FirstName = "coachFirst",
LastName = "coachLast",
Gender = Gender.Female,
Email = "*****@*****.**"
};
Assistant assistant1 = new Assistant()
{
FirstName = "assistantFirst",
LastName = "assistantLast",
Gender = Gender.Female,
Email = "*****@*****.**"
};
Assistant assistant2 = new Assistant()
{
FirstName = "assistantFist",
LastName = "assistantLast",
Gender = Gender.Male,
Email = "*****@*****.**"
};
instructor.EllCoach = coach;
instructor.Assistants.Add(assistant1);
instructor.Assistants.Add(assistant2);
//When
InstructorDto dto = GetMapped <InstructorDto, Instructor>(instructor);
//Then
Assert.Equal(instructor.Id.ToString(), dto.Id);
Assert.Equal(instructor.FirstName, dto.FirstName);
Assert.Equal(instructor.LastName, dto.LastName);
Assert.Equal(instructor.Email, dto.Email);
Assert.Equal(instructor.Gender, dto.Gender);
Assert.Equal(instructor.Department, dto.Department);
Assert.Equal(DataAccessConstants.noSqlInstructorVersion, dto.Version);
Assert.Equal(DataAccessConstants.noSqlInstructorType, dto.Type);
Assert.Equal(instructor.EllCoach.Id.ToString(), dto.EllCoach.Id);
// Assert.Equal(instructor.EllCoach.FirstName, dto.EllCoach.FirstName);
// Assert.Equal(instructor.EllCoach.LastName, dto.EllCoach.LastName);
Assert.Equal(instructor.EllCoach.Email, dto.EllCoach.Email);
// Assert.Equal(instructor.EllCoach.Gender, dto.EllCoach.Gender);
Assert.Equal(DataAccessConstants.noSqlEllCoachShortType, dto.EllCoach.Type);
Assert.Equal(DataAccessConstants.noSqlPersonVersion, dto.EllCoach.Version);
Assert.Equal(assistant1.Id.ToString(), dto.Assistants[0].Id);
// Assert.Equal(assistant1.FirstName, dto.Assistants[0].FirstName);
// Assert.Equal(assistant1.LastName, dto.Assistants[0].LastName);
Assert.Equal(assistant1.Email, dto.Assistants[0].Email);
// Assert.Equal(assistant1.Gender, dto.Assistants[0].Gender);
Assert.Equal(assistant2.Id.ToString(), dto.Assistants[1].Id);
// Assert.Equal(assistant2.FirstName, dto.Assistants[1].FirstName);
// Assert.Equal(assistant2.LastName, dto.Assistants[1].LastName);
Assert.Equal(assistant2.Email, dto.Assistants[1].Email);
// Assert.Equal(assistant2.Gender, dto.Assistants[1].Gender);
Assert.All(dto.Assistants, assistant => Assert.Equal(DataAccessConstants.noSqlPersonVersion, assistant.Version));
Assert.All(dto.Assistants, assistant => Assert.Equal(DataAccessConstants.noSqlAssistantShortType, assistant.Type));
}
public void AddCoach(EllCoach coach, Instructor instructor)
{
instructor.EllCoach = coach;
coach.Instructors.Add(instructor);
}
