public void MVC_LecturerTests_EnrolledStudents()
{
Mock <IUserRepository> usrRepMock = new Mock <IUserRepository>();
Mock <ICourseRepository> corRepMock = new Mock <ICourseRepository>();
Mock <IScoreRepository> scrRepMock = new Mock <IScoreRepository>();
Mock <IComponentRepository> comRepMock = new Mock <IComponentRepository>();
usrRepMock.Setup(c => c.GetById(1)).Returns(lecturer);
corRepMock.Setup(c => c.GetById(1)).Returns(course);
IList <Component> components = new List <Component>();
comRepMock.Setup(c => c.GetAll()).Returns(components);
IList <Score> scores = new List <Score>();
scrRepMock.Setup(c => c.GetAll()).Returns(scores);
usrRepMock.Setup(c => c.GetByCourse(It.IsAny <Course>())).Returns(new List <Student>()
{
student
});
var controller = new LecturerController(corRepMock.Object, scrRepMock.Object, usrRepMock.Object, comRepMock.Object);
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(p => p.HttpContext.Session["userId"]).Returns(1);
controllerContext.SetupGet(p => p.HttpContext.Session["email"]).Returns("*****@*****.**");
controller.ControllerContext = controllerContext.Object;
var result = controller.StudentsEnrolled(1, false) as ViewResult;
var viewModel = (List <StudentEnrollementViewModel>)result.ViewData.Model;
Assert.AreEqual(1, viewModel.Count);
}
public void MVC_ComponentTests_DisplayCourseComponents()
{
Mock <IUserRepository> usrRepMock = new Mock <IUserRepository>();
Mock <ICourseRepository> corRepMock = new Mock <ICourseRepository>();
Mock <IScoreRepository> scrRepMock = new Mock <IScoreRepository>();
Mock <IComponentRepository> comRepMock = new Mock <IComponentRepository>();
usrRepMock.Setup(c => c.GetById(1)).Returns(lecturer);
corRepMock.Setup(c => c.GetById(1)).Returns(course);
IList <Component> components = new List <Component>();
comRepMock.Setup(c => c.GetAll()).Returns(components);
var controller = new LecturerController(corRepMock.Object, scrRepMock.Object, usrRepMock.Object, comRepMock.Object);
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(p => p.HttpContext.Session["userId"]).Returns(1);
controllerContext.SetupGet(p => p.HttpContext.Session["email"]).Returns("*****@*****.**");
controller.ControllerContext = controllerContext.Object;
var result = controller.Component(1) as ViewResult;
var viewModel = (IList <ComponentViewModel>)result.ViewData.Model;
Assert.AreEqual(1, viewModel.Count);
}
public void MVC_LecturerTests_Index()
{
Mock <IUserRepository> usrRepMock = new Mock <IUserRepository>();
Mock <ICourseRepository> corRepMock = new Mock <ICourseRepository>();
Mock <IScoreRepository> scrRepMock = new Mock <IScoreRepository>();
Mock <IComponentRepository> comRepMock = new Mock <IComponentRepository>();
usrRepMock.Setup(c => c.GetById(1)).Returns(lecturer);
corRepMock.Setup(c => c.GetByLecturerInChargerId(1)).Returns(new List <Course>()
{
course
});
comRepMock.Setup(c => c.GetById(1)).Returns(component);
scrRepMock.Setup(c => c.GetById(1)).Returns(score);
//GetByLecturerInChargerId
var controller = new LecturerController(corRepMock.Object, scrRepMock.Object, usrRepMock.Object, comRepMock.Object);
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(p => p.HttpContext.Session["userId"]).Returns(1);
controllerContext.SetupGet(p => p.HttpContext.Session["email"]).Returns("*****@*****.**");
controller.ControllerContext = controllerContext.Object;
var result = controller.Index() as ViewResult;
var viewModel = (IList <LecturerCourseViewModel>)result.ViewData.Model;
Assert.AreEqual(1, viewModel.Count);
}
private void setalllecturerslist()
{
listAllLecturers.Items.Clear();
listAllLecturers.DataSource = LecturerController.FilterLecturersSession("");
listAllLecturers.DisplayMember = "text";
listAllLecturers.ValueMember = "value";
}
public LecturerForm()
{
InitializeComponent();
controller = new LecturerController();
InsertedLecturers = new List <Lecturer>();
FormClosed += LecturerForm_Closed;
}
public StudentManagementView(StudentController studentController, CourseController courseController, ClassController classController, LecturerController lecturerController, RoomController roomController)
{
this.studentController = studentController;
this.courseController = courseController;
this.classController = classController;
this.lecturerController = lecturerController;
this.roomController = roomController;
}
private void TestDisplayEmptyLecturerList()
{
Console.WriteLine("Testing Display Empty Lecturer List");
LecturerController nLC = new LecturerController();
LecturerManagementView nLMV = new LecturerManagementView(nLC);
nLMV.DisplayLecturer();
Console.WriteLine();
}
public void Setup()
{
var entities = new List <Lecturer>
{
new Lecturer
{
Id = 1,
Name = "Test"
},
new Lecturer
{
Id = 2,
Name = "Test2"
}
};
var config = new MapperConfiguration(opts =>
{
opts.AddProfile(new LecturerProfile());
});
var collection = entities.AsQueryable().BuildMock();
var mapper = config.CreateMapper();
Service = new Mock <ILecturerService>();
Logger = new Mock <ILogger <LecturerController> >();
Service.Setup(x => x.GetAllLecturers())
.Returns(collection.Object);
Service.Setup(x => x.GetAllLecturers())
.Returns(collection.Object);
Service.Setup(x => x.GetAllLecturersWithCourses())
.Returns(collection.Object);
Service.Setup(x => x.GetLecturerById(It.IsAny <int>()))
.Returns((int id) => Task.Run(() => entities.Find(t => t.Id == id)));
Service.Setup(x => x.GetLecturerWithCoursesById(It.IsAny <int>()))
.Returns((int id) => Task.Run(() => entities.Find(t => t.Id == id)));
Service.Setup(x => x.CreateLecturer(It.IsAny <Lecturer>()))
.Callback((Lecturer lecturer) => entities.Add(lecturer));
Service.Setup(x => x.UpdateLecturer(It.IsAny <Lecturer>()))
.Callback((Lecturer lecturer) => entities[entities.FindIndex(x => x.Id == lecturer.Id)] = lecturer);
Service.Setup(x => x.DeleteLecturer(It.IsAny <Lecturer>()))
.Callback((Lecturer lecturer) => entities.RemoveAt(entities.FindIndex(x => x.Id == lecturer.Id)));
Controller = new LecturerController(Service.Object, mapper, Logger.Object);
}
private void setalllecturerslist()
{
listAllLecturers.Items.Clear();
DataTable dt = LecturerController.FilterLecturers("");
listAllLecturers.DataSource = dt;
listAllLecturers.DisplayMember = "Name";
listAllLecturers.ValueMember = "ID";
listAllLecturers.SelectedIndex = -1;
}
public void Create_Get_ReturnsViewResult()
{
// Arrange
var controller = new LecturerController(null);
//Act
var result = controller.Create();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
}
public void GradeMarkReturnViewCreateRegisterIfRegisterNull()
{
var mockCourse = new Mock <ICourseRepository>();
var mockRegister = new Mock <IRegisterRepository>();
mockCourse.Setup(r => r.GetMarks(1)).Returns(new List <Register>());
LecturerController controller = new LecturerController(mockCourse.Object, mockRegister.Object);
ViewResult result = controller.GradeMark("student2", 2);
Assert.AreEqual(result.ViewName, "CreateRegister");
}
public void GradeReturnContentResultIfStudentsCountZero()
{
var mockCourse = new Mock <ICourseRepository>();
var mockRegister = new Mock <IRegisterRepository>();
mockCourse.Setup(c => c.GetWithStudents(1)).Returns(new Course());
LecturerController controller = new LecturerController(mockCourse.Object, mockRegister.Object);
ActionResult result = controller.Grade(1);
Assert.AreEqual(result.GetType(), typeof(ContentResult));
}
public void CreateRegisterReturnRedirect()
{
var mockCourse = new Mock <ICourseRepository>();
var mockRegister = new Mock <IRegisterRepository>();
LecturerController controller = new LecturerController(mockCourse.Object, mockRegister.Object);
mockRegister.Setup(r => r.Create(new Register(), 1, "student")).Verifiable();
ActionResult result = controller.CreateRegister(new RegisterViewModel());
Assert.AreEqual(result.GetType(), typeof(RedirectToRouteResult));
}
public void GradeReturnHttpNotFoundIfExceptionOccur()
{
var mockCourse = new Mock <ICourseRepository>();
var mockRegister = new Mock <IRegisterRepository>();
mockCourse.Setup(c => c.GetWithStudents(1)).Throws(new Exception());
LecturerController controller = new LecturerController(mockCourse.Object, mockRegister.Object);
ActionResult result = controller.Grade(1);
Assert.AreEqual(result.GetType(), typeof(HttpNotFoundResult));
}
public TestHarness()
{
cc = new CourseController();
lc = new LecturerController();
rc = new RoomController();
clc = new ClassController();
sc = new StudentController();
cmv = new CourseManagementView(cc);
lmv = new LecturerManagementView(lc);
rmv = new RoomManagementView(rc);
clmv = new ClassManagementView(clc, cc, lc, rc);
smv = new StudentManagementView(sc, cc, clc, lc, rc);
}
public void Create_ReturnsBadRequest_WhenLecturerParameterIsNull()
{
//Arrange
Lecturer lecturer = null;
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
IActionResult actual = controller.Create(lecturer);
//Assert
actual.Should().BeAssignableTo <BadRequestResult>();
}
public void Edit_ReturnNotFound_WhenLecturerDoesNotExist()
{
//Arrange
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
IActionResult actual = controller.Edit(0);
//Assert
var expected = new NotFoundResult();
actual.Should().BeEquivalentTo(expected);
}
public void Edit_Get_ReturnsNotFound_WhenNonExistingLecturerId()
{
// Arrange
int nonExistingLecturerId = 0;
var lecturerServiceMock = Substitute.For <LecturerService>();
lecturerServiceMock.GetLecturer(nonExistingLecturerId).Returns(default(Lecturer));
var controller = new LecturerController(lecturerServiceMock);
// Act
var result = controller.Edit(nonExistingLecturerId);
// Assert
var viewResult = Assert.IsType <NotFoundResult>(result);
}
public void Lecturers_ReturnsViewResult_WithListOfLecturers()
{
// Arrange
var lecturerServiceMock = Substitute.For <LecturerService>();
lecturerServiceMock.GetAllLecturers().Returns(new List <Models.AcademyModels.Lecturer>());
var controller = new LecturerController(lecturerServiceMock);
//Act
var result = controller.Lecturers();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <Lecturer> >(viewResult.Model);
}
public void Edit_Get_ReturnsViewResult_WithLecturer()
{
// Arrange
int existingLecturerId = 1;
var lecturerServiceMock = Substitute.For <LecturerService>();
lecturerServiceMock.GetLecturer(existingLecturerId).Returns(new Lecturer());
var controller = new LecturerController(lecturerServiceMock);
// Act
var result = controller.Edit(existingLecturerId);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <Lecturer>(viewResult.Model);
}
public async Task Lecturers_ReturnsViewResult_WithListOfLecturers()
{
// Arrange
LecturerService lecturersService = Substitute.For <LecturerService>();
lecturersService.GetAllLecturers().Returns(this.GetLecturersList());
var controller = new LecturerController(lecturersService);
// Act
var result = controller.Lecturers();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <List <Lecturer> >(viewResult.ViewData.Model);
Assert.Equal(2, model.Count);
}
public void Create_RedirectsToLecturersAndCreatesLecturer_WhenRequestIsValid()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "New Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
var actionResult = controller.Create(lecturer);
lecturerService.Received().CreateLecturer(lecturer);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be("Lecturers");
}
public void Create_ReturnsViewResult_WhenLecturerModelStateIsInvalid()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "New Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
LecturerController controller = new LecturerController(lecturerService);
//Act
controller.ModelState.AddModelError("test", "test"); //makes model invalid => if (!ModelState.IsValid)
IActionResult actual = controller.Create(lecturer);
//Assert
Assert.IsAssignableFrom <ViewResult>(actual);
actual.Should().BeAssignableTo <ViewResult>();
}
private void gridlecturers_CellMouseClick(object sender, DataGridViewCellMouseEventArgs e)
{
try
{
if (e.RowIndex >= 0)
{
DataGridViewRow row = gridlecturers.Rows[e.RowIndex];
int lecturerid = Convert.ToInt32(row.Cells[0].Value.ToString());
Lecturer lecturer = LecturerController.SelectedLecturer(lecturerid);
if (lecturer != null)
{
lbllecturerid.Text = lecturerid.ToString();
txtlecturername.Text = lecturer.lecturername;
combocenter.SelectedItem = lecturer.center;
txtemployeeid.Text = lecturer.employeeid;
combobuilding.Text = lecturer.building;
combofaculty.SelectedItem = lecturer.faculty;
combolevel.SelectedItem = lecturer.level.ToString();
combodepartment.SelectedItem = lecturer.department;
txtrank.Text = lecturer.rank;
}
else
{
lbllecturerid.Text = string.Empty;
txtlecturername.Text = string.Empty;
combocenter.SelectedIndex = -1;
txtemployeeid.Text = string.Empty;
combobuilding.SelectedIndex = -1;
combofaculty.SelectedIndex = -1;
combolevel.SelectedIndex = -1;
combodepartment.SelectedIndex = -1;
txtrank.Text = string.Empty;
}
}
}
catch (FormatException fe)
{
clear();
MessageBox.Show("no data selected");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void GradeReturnViewResultIfStudentsCountMoreThanZero()
{
var mockCourse = new Mock <ICourseRepository>();
var mockRegister = new Mock <IRegisterRepository>();
mockCourse.Setup(c => c.GetWithStudents(1)).Returns(new Course()
{
Students = new List <Student> {
new Student()
}
});
mockCourse.Setup(r => r.GetMarks(1)).Returns(new List <Register>());
LecturerController controller = new LecturerController(mockCourse.Object, mockRegister.Object);
ActionResult result = controller.Grade(1);
Assert.AreEqual(result.GetType(), typeof(ViewResult));
}
public void Delete_RedirectsToLecturers_WhenLecturerExists()
{
//Arrange
Lecturer lecturer = new Lecturer()
{
Name = "Test Lecturer"
};
LecturerService lecturersService = Substitute.For <LecturerService>();
lecturersService.GetLecturerById(5).Returns(lecturer);
LecturerController controller = new LecturerController(lecturersService);
//Act
var actionResult = controller.Delete(lecturer.Id);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be("Lecturers");
}
public void Delete_RedirectToLecturers()
{
// Arrange
int lecturerId = 1;
var lecturerServiceMock = Substitute.For <LecturerService>();
lecturerServiceMock.DeleteLecturer(lecturerId).Returns(true);
var controller = new LecturerController(lecturerServiceMock);
// Act
var result = controller.Delete(lecturerId);
// Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(redirectToActionResult.ControllerName);
Assert.Equal("Lecturers", redirectToActionResult.ActionName);
}
private void btndelete_Click(object sender, EventArgs e)
{
try
{
int lecturerid = Convert.ToInt32(lbllecturerid.Text);
string message = LecturerController.DeleteLecturer(lecturerid);
MessageBox.Show(message);
loadgrid(txtlecturerfilter.Text);
clear();
}
catch (FormatException fe)
{
MessageBox.Show("please select a specific lecturer");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void Edit_Post_RedirectToLecturers()
{
// Arrange
Lecturer lecturerForEditing = new Lecturer();
var lecturerSericeMock = Substitute.For <LecturerService>();
lecturerSericeMock.UpdateLecturer(lecturerForEditing).Returns(true);
var controller = new LecturerController(lecturerSericeMock);
// Act
var result = controller.Edit(lecturerForEditing);
// Assert
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Null(redirectToActionResult.ControllerName);
Assert.Equal("Lecturers", redirectToActionResult.ActionName);
}
public void Edit_RedirectsToLecturers_WhenModelStateIsValid()
{
//Arrange
Lecturer lecturer = new Lecturer {
Name = "Test Lecturer"
};
LecturerService lecturerService = Substitute.For <LecturerService>();
lecturerService.GetLecturerById(5).Returns(lecturer);
LecturerController controller = new LecturerController(lecturerService);
//Act
var actionResult = controller.Edit(lecturer);
lecturerService.Received().UpdateLecturer(lecturer);
// Assert
actionResult.Should().BeOfType <RedirectToActionResult>().Which.ActionName.Should().Be("Lecturers");
}
