public static Course ToDoamin(this CourseTO courseTO)
{
return(new Course
{
ID = courseTO.ID,
Name = courseTO.Name,
});
}
public CourseTO Add(CourseTO Entity)
{
if (Entity.Id != 0)
{
return(Entity);
}
return(registrationContext.Courses.Add(Entity.ToEF()).Entity.ToTransfertObject());
}
public static CourseEF ToEF(this CourseTO course)
{
return(new CourseEF()
{
Id = course.Id,
Name = course.Name,
IsArchived = course.IsArchived
});
}
public void Should_Have_One_UserSessions()
{
#region TOInitialization
UserTO student = new UserTO()
{
Id = 1,
Name = "Jacky Fringant",
Email = "*****@*****.**",
Role = UserRole.Attendee,
};
UserTO teacher = new UserTO()
{
Id = 2,
Name = "Johnny Begood",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
CourseTO sql = new CourseTO()
{
Id = 1,
Name = "SQL"
};
SessionTO sessionTO = new SessionTO()
{
Id = 1,
Teacher = teacher,
Course = sql,
SessionDays = new List <SessionDayTO>()
{
new SessionDayTO()
{
Id = 1, Date = new DateTime(2020, 2, 3), PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Id = 2, Date = new DateTime(2020, 2, 4), PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Id = 3, Date = new DateTime(2020, 2, 5), PresenceType = SessionPresenceType.MorningAfternoon
}
},
Attendees = new List <UserTO>()
{
student,
}
};
#endregion TOInitialization
SessionEF sessionConverted = sessionTO.ToEF();
}
public void Should_Throw_Exception_When_Course_IsArchived()
{
var options = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using (var context = new RegistrationContext(options))
{
IRSUserRepository userRepository = new UserRepository(context);
IRSSessionRepository sessionRepository = new SessionRepository(context);
IRSCourseRepository courseRepository = new CourseRepository(context);
var Teacher = new UserTO()
{
//Id = 420,
Name = "Christian",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
var Michou = new UserTO()
{
//Id = 45,
Name = "Michou Miraisin",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var AddedTeacher = userRepository.Add(Teacher);
var AddedAttendee = userRepository.Add(Michou);
context.SaveChanges();
var SQLCourse = new CourseTO()
{
//Id = 28,
Name = "SQL",
IsArchived = true
};
var AddedCourse = courseRepository.Add(SQLCourse);
context.SaveChanges();
var SQLSession = new SessionTO()
{
//Id = 1,
Attendees = new List <UserTO>()
{
AddedAttendee
},
Course = AddedCourse,
Teacher = AddedTeacher,
};
Assert.ThrowsException <ArgumentException>(() => sessionRepository.Add(SQLSession));
}
}
public void RemoveCourse_ThrowException_WhenCourseIdIsZero()
{
//ARRANGE
var courseIdZero = new CourseTO {
Id = 0, Name = "User Name"
};
var assistant = new RSAssistantRole(MockUofW.Object);
//ASSERT
Assert.ThrowsException <Exception>(() => assistant.RemoveCourse(courseIdZero));
}
public void AddCourse_ThrowException_WhenCourseIDisDiferentThanZero()
{
//ARRANGE
var ass = new RSAssistantRole(new Mock <IRSUnitOfWork>().Object);
var course = new CourseTO {
Id = 100, Name = "Name"
};
//ASSERT
Assert.ThrowsException <Exception>(() => ass.AddCourse(course));
}
public void UpdateCourse_ThrowsIsNullOrWhiteSpaceException_WhenWhiteSpaceNameIsProvided()
{
//ARRANGE
var ass = new RSAssistantRole(MockUofW.Object);
var courseNameWhiteSpace = new CourseTO {
Id = 1, Name = " "
};
//ASSERT
Assert.ThrowsException <IsNullOrWhiteSpaceException>(() => ass.UpdateCourse(courseNameWhiteSpace));
}
public void UpdateCourse_ThrowException_WhenCourseIdIsZero()
{
//ARRANGE
var ass = new RSAssistantRole(new Mock <IRSUnitOfWork>().Object);
var course = new CourseTO {
Id = 0
};
//ASSERT
Assert.ThrowsException <Exception>(() => ass.RemoveCourse(course));
}
public void UpdateCourse_ReturnsTrue_WhenAValidCourseIsProvidedAndUpdatedInDB()
{
MockCourseRepository.Setup(x => x.Update(It.IsAny <CourseTO>()));
MockUofW.Setup(x => x.CourseRepository).Returns(MockCourseRepository.Object);
var ass = new RSAssistantRole(MockUofW.Object);
var course = new CourseTO {
Id = 1, Name = "Name"
};
Assert.IsTrue(ass.UpdateCourse(course));
}
public static Course ToDomain(this CourseTO courseTO)
{
if (courseTO is null)
{
throw new ArgumentNullException(nameof(courseTO));
}
return(new Course
{
Id = courseTO.Id,
Name = courseTO.Name,
});
}
public void AddCourse_NewCourse_Test()
{
//ARRANGE
MockCourseRepository.Setup(x => x.Add(It.IsAny <CourseTO>()));
MockUofW.Setup(x => x.CourseRepository).Returns(MockCourseRepository.Object);
var ass = new RSAssistantRole(MockUofW.Object);
var course = new CourseTO {
Id = 0, Name = "Name"
};
//ASSERT
Assert.IsTrue(ass.AddCourse(course));
}
public void RemoveCourse_ReturnsTrue_WhenCourseIsProvidedAndRemovedFromDB_Test()
{
//ARRANGE
MockCourseRepository.Setup(x => x.Remove(It.IsAny <CourseTO>()));
MockUofW.Setup(x => x.CourseRepository).Returns(MockCourseRepository.Object);
var assistant = new RSAssistantRole(MockUofW.Object);
var courseToRemove = new CourseTO {
Id = 1, Name = "Course Name"
};
//ASSERT
Assert.IsTrue(assistant.RemoveCourse(courseToRemove));
}
public CourseTO Update(CourseTO Entity)
{
if (!registrationContext.Courses.Any(x => x.Id == Entity.Id))
{
throw new KeyNotFoundException($"Can't find course to update. CourseRepository");
}
var attachedUser = registrationContext.Courses.FirstOrDefault(x => x.Id == Entity.Id);
if (attachedUser != default)
{
attachedUser.UpdateFromDetached(Entity.ToEF());
}
return(registrationContext.Courses.Update(attachedUser).Entity.ToTransfertObject());
}
public void RemoveCourse_CourseRepositoryIsCalledOnce_WhenAValidCourseIsProvidedAndRemovedFromDB()
{
//ARRANGE
MockCourseRepository.Setup(x => x.Remove(It.IsAny <CourseTO>()));
MockUofW.Setup(x => x.CourseRepository).Returns(MockCourseRepository.Object);
var ass = new RSAssistantRole(MockUofW.Object);
var courseToRemoveOnce = new CourseTO {
Id = 1, Name = "User Name"
};
//ACT
ass.RemoveCourse(courseToRemoveOnce);
MockCourseRepository.Verify(x => x.Remove(It.IsAny <CourseTO>()), Times.Once);
}
public void AddCourse_ThrowIsNullOrWhiteSpaceException_WhenCourseNameIsAnEmptyString()
{
//ARRANGE
var ass = new RSAssistantRole(MockUofW.Object);
var couNameWithWhiteSpace = new CourseTO {
Id = 0, Name = " "
};
var couWithNameNull = new CourseTO {
Id = 0, Name = null
};
//ASSERT
Assert.ThrowsException <IsNullOrWhiteSpaceException>(() => ass.AddCourse(couNameWithWhiteSpace));
Assert.ThrowsException <IsNullOrWhiteSpaceException>(() => ass.AddCourse(couWithNameNull));
}
public void AddCourse_UserRepositoryIsCalledOnce_WhenAValidCourseIsProvidedAndAddInDB()
{
//ARRANGE
MockCourseRepository.Setup(x => x.Add(It.IsAny <CourseTO>()));
MockUofW.Setup(x => x.CourseRepository).Returns(MockCourseRepository.Object);
var ass = new RSAssistantRole(MockUofW.Object);
var course = new CourseTO {
Id = 0, Name = "Name"
};
//ASSERT
ass.AddCourse(course);
MockCourseRepository.Verify(x => x.Add(It.IsAny <CourseTO>()), Times.Once);
}
public void RemoveCourse_ThrowException_WhenNullCourseIsProvided()
{
var option = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using var memoryCtx = new RegistrationContext(option);
var courseRepository = new CourseRepository(memoryCtx);
var course1 = new CourseTO()
{
Name = "course1"
};
// ACT & ASSERT
Assert.ThrowsException <ArgumentNullException>(() => courseRepository.Remove(1));
}
public void UpdateCourse_CourseRepositoryIsCalledOnce_WhenAValidCourseIsProvidedAndUpdatedInDB()
{
//ARRANGE
MockCourseRepository.Setup(x => x.Update(It.IsAny <CourseTO>()));
MockUofW.Setup(x => x.CourseRepository).Returns(MockCourseRepository.Object);
var ass = new RSAssistantRole(MockUofW.Object);
var course = new CourseTO {
Id = 1, Name = "Name"
};
//ACT
ass.UpdateCourse(course);
//VERIFY
MockCourseRepository.Verify(x => x.Update(It.IsAny <CourseTO>()), Times.Once);
}
public bool RemoveCourse(CourseTO courseTo)
{
if (courseTo is null)
{
throw new ArgumentNullException(nameof(courseTo));
}
if (courseTo.Id == 0)
{
throw new Exception("Course does not exist");
}
try
{
iRSUnitOfWork.CourseRepository.Remove(courseTo.ToDomain().ToTransfertObject());
return(true);
}
catch (Exception)
{
throw;
}
}
public bool UpdateCourse(CourseTO courseTo)
{
if (courseTo is null)
{
throw new ArgumentNullException(nameof(courseTo));
}
if (courseTo.Id == 0)
{
throw new Exception("Course does not exist");
}
courseTo.Name.IsNullOrWhiteSpace("Missing Course Name");
try
{
iRSUnitOfWork.CourseRepository.Update(courseTo.ToDomain().ToTransfertObject());
return(true);
}
catch (Exception)
{
throw;
}
}
public bool AddCourse(CourseTO courseTo)
{
if (courseTo is null)
{
throw new ArgumentNullException(nameof(courseTo));
}
if (courseTo.Id != 0)
{
throw new Exception("Existing Course");
}
courseTo.Name.IsNullOrWhiteSpace("Missing course name");
try
{
iRSUnitOfWork.CourseRepository.Add(courseTo.ToDomain().ToTransfertObject());
return(true);
}
catch (Exception)
{
throw;
}
}
public void GetAllCourses_Successful()
{
//ARRANGE
var option = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using var memoryCtx = new RegistrationContext(option);
var courseRepository = new CourseRepository(memoryCtx);
var course1 = new CourseTO()
{
Name = "course1"
};
var course2 = new CourseTO()
{
Name = "course2"
};
var course3 = new CourseTO()
{
Name = "course3"
};
var course4 = new CourseTO()
{
Name = "course4"
};
courseRepository.Add(course1);
courseRepository.Add(course2);
courseRepository.Add(course3);
courseRepository.Add(course4);
memoryCtx.SaveChanges();
// ACT
// ASSERT
Assert.AreEqual(4, courseRepository.GetAll().Count());
}
public void Should_Contain_One_Attendee()
{
#region TOInitialization
UserTO student = new UserTO()
{
Id = 1,
Name = "Jacky Fringant",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Attendee,
};
UserTO teacher = new UserTO()
{
Id = 2,
Name = "Johnny Begood",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Teacher
};
CourseTO sql = new CourseTO()
{
Id = 1,
Name = "SQL"
};
SessionTO sessionTO = new SessionTO()
{
Id = 1,
Teacher = teacher,
Course = sql,
SessionDays = new List <SessionDayTO>()
{
new SessionDayTO()
{
Id = 1, Date = new DateTime(2020, 2, 3), PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Id = 2, Date = new DateTime(2020, 2, 4), PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Id = 3, Date = new DateTime(2020, 2, 5), PresenceType = SessionPresenceType.MorningAfternoon
}
},
Attendees = new List <UserTO>()
{
student,
}
};
#endregion TOInitialization
#region EFInitialization
UserEF studentEF = new UserEF()
{
Id = 1,
Name = "Jacky Fringant",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Attendee,
};
UserEF teacherEF = new UserEF()
{
Id = 2,
Name = "Johnny Begood",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Teacher
};
CourseEF sqlEF = new CourseEF()
{
Id = 1,
Name = "SQL"
};
SessionEF sessionEF = new SessionEF()
{
Id = 1,
Course = sqlEF,
};
List <UserSessionEF> userSessions = new List <UserSessionEF>()
{
new UserSessionEF
{
SessionId = sessionEF.Id,
Session = sessionEF,
UserId = studentEF.Id,
User = studentEF
},
new UserSessionEF
{
SessionId = sessionEF.Id,
Session = sessionEF,
UserId = teacherEF.Id,
User = teacherEF
},
};
sessionEF.UserSessions = userSessions;
#endregion EFInitialization
SessionTO sessionConverted = sessionEF.ToTransfertObject();
Assert.AreEqual(1, sessionConverted.Attendees.Count);
}
public void Should_Return_2_Session()
{
var options = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using (var context = new RegistrationContext(options))
{
IRSUserRepository userRepository = new UserRepository(context);
IRSSessionRepository sessionRepository = new SessionRepository(context);
IRSCourseRepository courseRepository = new CourseRepository(context);
var Teacher = new UserTO()
{
//Id = 420,
Name = "Christian",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
var Michou = new UserTO()
{
//Id = 45,
Name = "Michou Miraisin",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var Isabelle = new UserTO()
{
Name = "Isabelle Balkany",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var AddedTeacher = userRepository.Add(Teacher);
var AddedAttendee = userRepository.Add(Michou);
var AddedAttendee2 = userRepository.Add(Isabelle);
context.SaveChanges();
var SQLCourse = new CourseTO()
{
Name = "SQL"
};
var MVCCourse = new CourseTO()
{
Name = "MVC"
};
var AddedCourse = courseRepository.Add(SQLCourse);
var AddedCourse2 = courseRepository.Add(MVCCourse);
context.SaveChanges();
var SQLSession = new SessionTO()
{
Attendees = new List <UserTO>()
{
AddedAttendee
},
Course = AddedCourse,
Teacher = AddedTeacher,
SessionDays = new List <SessionDayTO>()
{
new SessionDayTO()
{
Date = new DateTime(2020, 02, 20),
PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Date = new DateTime(2020, 02, 21),
PresenceType = SessionPresenceType.MorningAfternoon
}
}
};
var MVCSession = new SessionTO()
{
Attendees = new List <UserTO>()
{
AddedAttendee2
},
Course = AddedCourse,
Teacher = AddedTeacher,
SessionDays = new List <SessionDayTO>()
{
new SessionDayTO()
{
Date = new DateTime(2020, 03, 20),
PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Date = new DateTime(2020, 03, 21),
PresenceType = SessionPresenceType.MorningAfternoon
}
}
};
var AddedSession = sessionRepository.Add(SQLSession);
context.SaveChanges();
Assert.AreEqual(0, sessionRepository.GetSessionsByDate(new DateTime(2020, 02, 20)).Count());
}
}
public void ShouldReturn_2Students()
{
var options = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using (var context = new RegistrationContext(options))
{
IRSUserRepository userRepository = new UserRepository(context);
IRSSessionRepository sessionRepository = new SessionRepository(context);
IRSCourseRepository courseRepository = new CourseRepository(context);
var Teacher = new UserTO()
{
//Id = 420,
Name = "Christian",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
var Michou = new UserTO()
{
//Id = 45,
Name = "Michou Miraisin",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var Isabelle = new UserTO()
{
//Id = 45,
Name = "Isabelle Balkany",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var AddedTeacher = userRepository.Add(Teacher);
var AddedAttendee = userRepository.Add(Michou);
var AddedAttendee2 = userRepository.Add(Isabelle);
context.SaveChanges();
var SQLCourse = new CourseTO()
{
//Id = 28,
Name = "SQL"
};
var AddedCourse = courseRepository.Add(SQLCourse);
context.SaveChanges();
var SQLSession = new SessionTO()
{
//Id = 1,
Attendees = new List <UserTO>()
{
Michou, Isabelle
},
Course = AddedCourse,
Teacher = Teacher,
};
var AddedSession = sessionRepository.Add(SQLSession);
context.SaveChanges();
Assert.AreEqual(2, sessionRepository.GetStudents(AddedSession).Count());
}
}
public void Should_Have_Same_Teacher_As_TO()
{
#region TOInitialization
UserTO student = new UserTO()
{
Id = 1,
Name = "Jacky Fringant",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Attendee,
};
UserTO teacher = new UserTO()
{
Id = 2,
Name = "Johnny Begood",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Teacher
};
CourseTO sql = new CourseTO()
{
Id = 1,
Name = "SQL"
};
SessionTO sessionTO = new SessionTO()
{
Id = 1,
Teacher = teacher,
Course = sql,
SessionDays = new List <SessionDayTO>()
{
new SessionDayTO()
{
Id = 1, Date = new DateTime(2020, 2, 3), PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Id = 2, Date = new DateTime(2020, 2, 4), PresenceType = SessionPresenceType.MorningAfternoon
},
new SessionDayTO()
{
Id = 3, Date = new DateTime(2020, 2, 5), PresenceType = SessionPresenceType.MorningAfternoon
}
},
Attendees = new List <UserTO>()
{
student,
}
};
#endregion TOInitialization
#region EFInitialization
UserEF studentEF = new UserEF()
{
Id = 1,
Name = "Jacky Fringant",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Attendee,
};
UserEF teacherEF = new UserEF()
{
Id = 2,
Name = "Johnny Begood",
Email = "*****@*****.**",
IsActivated = true,
Role = UserRole.Teacher
};
CourseEF sqlEF = new CourseEF()
{
Id = 1,
Name = "SQL"
};
SessionEF sessionEF = new SessionEF()
{
Id = 1,
Course = sqlEF,
Dates = new List <SessionDayEF>()
{
new SessionDayEF {
Id = 1, Date = new DateTime(2020, 01, 20), PresenceType = SessionPresenceType.MorningOnly
},
new SessionDayEF {
Id = 2, Date = new DateTime(2020, 01, 21), PresenceType = SessionPresenceType.MorningOnly
},
new SessionDayEF {
Id = 3, Date = new DateTime(2020, 01, 22), PresenceType = SessionPresenceType.MorningOnly
},
},
};
List <UserSessionEF> userSessions = new List <UserSessionEF>()
{
new UserSessionEF
{
SessionId = sessionEF.Id,
UserId = studentEF.Id
},
new UserSessionEF
{
SessionId = sessionEF.Id,
UserId = teacherEF.Id
}
};
sessionEF.UserSessions = userSessions;
#endregion EFInitialization
SessionEF sessionConverted = sessionTO.ToEF();
//Assert.AreEqual(sessionEF.Teacher.Id, sessionConverted.Teacher.Id);
}
public void Should_Insert_Session_when_valid()
{
var options = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using (var context = new RegistrationContext(options))
{
IRSUserRepository userRepository = new UserRepository(context);
IRSSessionRepository sessionRepository = new SessionRepository(context);
IRSCourseRepository courseRepository = new CourseRepository(context);
var Teacher = new UserTO()
{
//Id = 420,
Name = "Christian",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
var Michou = new UserTO()
{
//Id = 45,
Name = "Michou Miraisin",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var AddedTeacher = userRepository.Add(Teacher);
var AddedAttendee = userRepository.Add(Michou);
context.SaveChanges();
var SQLCourse = new CourseTO()
{
//Id = 28,
Name = "SQL"
};
var AddedCourse = courseRepository.Add(SQLCourse);
context.SaveChanges();
var SQLSession = new SessionTO()
{
//Id = 1,
Attendees = new List <UserTO>()
{
Michou
},
Course = AddedCourse,
Teacher = Teacher,
};
//By Amb
var mySession = new SessionTO()
{
Attendees = new List <UserTO> {
new UserTO {
Name = "AAA", Email = "*****@*****.**", Role = UserRole.Attendee, IsActivated = false
}
},
};
//By Amb
var AddedSession = sessionRepository.Add(SQLSession);
context.SaveChanges();
Assert.AreEqual(1, sessionRepository.GetAll().Count());
}
}
public void IsInSession_WhenValid()
{
//arrange
var options = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using var RSCxt = new RegistrationContext(options);
IRSUserRepository userRepository = new UserRepository(RSCxt);
IRSCourseRepository courseRepository = new CourseRepository(RSCxt);
IRSSessionRepository sessionRepository = new SessionRepository(RSCxt);
var Teacher = new UserTO()
{
Name = "Max",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
var Jack = new UserTO()
{
Name = "Jack Jack",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var John = new UserTO()
{
Name = "John",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var AddedUser0 = userRepository.Add(Teacher);
var AddedUser1 = userRepository.Add(Jack);
var AddedUser2 = userRepository.Add(John);
RSCxt.SaveChanges();
var SQLCourse = new CourseTO()
{
Name = "SQL"
};
var AddedCourse = courseRepository.Add(SQLCourse);
RSCxt.SaveChanges();
var SQLSession = new SessionTO()
{
Attendees = new List <UserTO>()
{
AddedUser1
},
Course = AddedCourse,
Teacher = AddedUser0,
};
var AddedSession = sessionRepository.Add(SQLSession);
RSCxt.SaveChanges();
//act
//assert
Assert.AreEqual(3, userRepository.GetAll().Count());
Assert.AreEqual(2, userRepository.GetUsersBySession(AddedSession).Count());
}
public void Modifying_Course()
{
var options = new DbContextOptionsBuilder <RegistrationContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using (var context = new RegistrationContext(options))
{
IRSUserRepository userRepository = new UserRepository(context);
IRSSessionRepository sessionRepository = new SessionRepository(context);
IRSCourseRepository courseRepository = new CourseRepository(context);
var Teacher = new UserTO()
{
Name = "Christian",
Email = "*****@*****.**",
Role = UserRole.Teacher
};
var Michou = new UserTO()
{
Name = "Michou Miraisin",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var Isabelle = new UserTO()
{
Name = "Isabelle Balkany",
Email = "*****@*****.**",
Role = UserRole.Attendee
};
var AddedTeacher = userRepository.Add(Teacher);
var AddedAttendee = userRepository.Add(Michou);
context.SaveChanges();
var SQLCourse = new CourseTO()
{
Name = "SQL"
};
var MVCCourse = new CourseTO()
{
Name = "MVC"
};
var AddedCourse = courseRepository.Add(SQLCourse);
var AddedCourse2 = courseRepository.Add(MVCCourse);
context.SaveChanges();
var SQLSession = new SessionTO()
{
Attendees = new List <UserTO>()
{
AddedAttendee,
},
Course = AddedCourse,
Teacher = AddedTeacher,
};
var AddedSession = sessionRepository.Add(SQLSession);
context.SaveChanges();
Assert.AreEqual("SQL", AddedSession.Course.Name);
AddedSession.Course = AddedCourse2;
AddedSession = sessionRepository.Update(AddedSession);
context.SaveChanges();
Assert.AreEqual("MVC", AddedSession.Course.Name);
}
}
