public void PutStudentTest()
        {
            Student updateStudentTestData;

            updateStudentTestData = StudentTestData.GetTestDataStudentUpdate();
            mockStudentRepository.Setup(m => m.Student.UpdateStudent(updateStudentTestData)).Returns(true);

            OkObjectResult content        = studentController.Put(updateStudentTestData).Result as OkObjectResult;
            HttpStatusCode httpStatusCode = (HttpStatusCode)content.StatusCode;

            var response = content.Value as ResponseModel <Student>;
            var actualUpdateSuccessMessage = response.Message;

            Assert.AreEqual(httpStatusCode, HttpStatusCode.OK);
            Assert.AreEqual(ResponseMessage.OnSuccessUpdateMessage, actualUpdateSuccessMessage);
        }
        public void GetStudentTest()
        {
            IEnumerable <Student> expectedStudents;

            expectedStudents = StudentTestData.GetExpectedStudents();
            var expectedStudentsTask = Task.FromResult(expectedStudents);

            mockStudentRepository.Setup(m => m.Student.GetAllStudentsAsync()).Returns(expectedStudentsTask);

            OkObjectResult content        = studentController.Get().Result as OkObjectResult;
            HttpStatusCode httpStatusCode = (HttpStatusCode)content.StatusCode;

            var response       = content.Value as ResponseModel <Student>;
            var actualStudents = response.DataCollection;

            Assert.AreEqual(httpStatusCode, HttpStatusCode.OK);
            Assert.AreEqual(expectedStudentsTask.Result.Count(), actualStudents.ToList().Count);
        }
        public void GetStudentTestById()
        {
            Student expectedStudent;

            expectedStudent = StudentTestData.GetExpectedStudent();

            var expectedStudentTask = Task.FromResult(expectedStudent);

            mockStudentRepository.Setup(m => m.Student.GetStudentByIdAsync(expectedStudent.Id)).Returns(expectedStudentTask);

            OkObjectResult content        = studentController.Get(expectedStudent.Id).Result as OkObjectResult;
            HttpStatusCode httpStatusCode = (HttpStatusCode)content.StatusCode;

            var response      = content.Value as ResponseModel <Student>;
            var actualStudent = response.DataObject;

            Assert.AreEqual(httpStatusCode, HttpStatusCode.OK);
            Assert.AreEqual(expectedStudentTask.Result.Id, actualStudent.Id);
        }
        public void DeleteStudentTest()
        {
            Student deleteStudentTestData;

            deleteStudentTestData = StudentTestData.GetTestDataStudentDelete();

            var expectedStudent = Task.FromResult(deleteStudentTestData);

            mockStudentRepository.Setup(m => m.Student.GetStudentByIdAsync(deleteStudentTestData.Id)).Returns(expectedStudent);
            mockStudentRepository.Setup(m => m.Student.DeleteStudent(deleteStudentTestData)).Returns(true);

            OkObjectResult content        = studentController.Delete(deleteStudentTestData.Id).Result as OkObjectResult;
            HttpStatusCode httpStatusCode = (HttpStatusCode)content.StatusCode;

            var response = content.Value as ResponseModel <Student>;
            var actualDeleteSuccessMessage = response.Message;

            Assert.AreEqual(httpStatusCode, HttpStatusCode.OK);
            Assert.AreEqual(ResponseMessage.OnSuccessDeleteMessage, actualDeleteSuccessMessage);
        }