private static DoctorsController GetDoctorsController()
{
var emptyDocData = Enumerable.Empty <Doctor>().AsQueryable();
var emptyEmpData = Enumerable.Empty <Employee>().AsQueryable();
var emptyUserData = Enumerable.Empty <User>().AsQueryable();
var mockDocSet = new Mock <DbSet <Doctor> >();
var mockEmpSet = new Mock <DbSet <Employee> >();
var mockUserSet = new Mock <DbSet <User> >();
var mockContext = new Mock <AlphaMedicContext>();
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.Provider).Returns(emptyDocData.Provider);
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.Expression).Returns(emptyDocData.Expression);
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.ElementType).Returns(emptyDocData.ElementType);
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.GetEnumerator()).Returns(() => emptyDocData.GetEnumerator());
mockContext.Setup(c => c.Doctors).Returns(mockDocSet.Object);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.Provider).Returns(emptyEmpData.Provider);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.Expression).Returns(emptyEmpData.Expression);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.ElementType).Returns(emptyEmpData.ElementType);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.GetEnumerator()).Returns(() => emptyEmpData.GetEnumerator());
//mockContext.Setup(c => c.Employees).Returns(mockEmpSet.Object);
//mockUserSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(emptyUserData.Provider);
//mockUserSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(emptyUserData.Expression);
//mockUserSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(emptyUserData.ElementType);
//mockUserSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(() => emptyUserData.GetEnumerator());
//mockContext.Setup(c => c.Users).Returns(mockUserSet.Object);
var service = new DoctorsController(mockContext.Object);
return(service);
}
public async Task Index_Returns_ViewResult()
{
IFixture fixture = new Fixture();
fixture.Behaviors.Add(new OmitOnRecursionBehavior());
var model = fixture.Create <DoctorsViewModel>();
_appService.Setup(c =>
c.GetDoctorsAppointmentsForDay(It.IsAny <string>(), It.IsAny <DateTime>(), CancellationToken.None))
.ReturnsAsync(model);
var appointmentsController = new DoctorsController(_appService.Object)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, "user") },
"test"))
}
}
};
var action = await appointmentsController.Index();
Assert.IsInstanceOf <ViewResult>(action);
}
private static DoctorsController GetDoctorsControllerWithData(
IEnumerable <Doctor> doctorsData
//IEnumerable<Employee> employerData,
//IEnumerable<User> userData
)
{
var docData = doctorsData.AsQueryable();
//var empData = employerData.AsQueryable();
//var usersData = userData.AsQueryable();
var mockDocSet = new Mock <DbSet <Doctor> >();
var mockEmpSet = new Mock <DbSet <Employee> >();
var mockUserSet = new Mock <DbSet <User> >();
var mockContext = new Mock <AlphaMedicContext>();
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.Provider).Returns(docData.Provider);
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.Expression).Returns(docData.Expression);
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.ElementType).Returns(docData.ElementType);
mockDocSet.As <IQueryable <Doctor> >().Setup(m => m.GetEnumerator()).Returns(() => docData.GetEnumerator());
mockContext.Setup(c => c.Doctors).Returns(mockDocSet.Object);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.Provider).Returns(empData.Provider);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.Expression).Returns(empData.Expression);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.ElementType).Returns(empData.ElementType);
//mockEmpSet.As<IQueryable<Employee>>().Setup(m => m.GetEnumerator()).Returns(() => empData.GetEnumerator());
//mockContext.Setup(c => c.Employees).Returns(mockEmpSet.Object);
//mockUserSet.As<IQueryable<User>>().Setup((IQueryable<User> m) => m.Provider).Returns(usersData.Provider);
//mockUserSet.As<IQueryable<User>>().Setup((IQueryable<User> m) => m.Expression).Returns(usersData.Expression);
//mockUserSet.As<IQueryable<User>>().Setup((IQueryable<User> m) => m.ElementType).Returns(usersData.ElementType);
//mockUserSet.As<IQueryable<User>>().Setup((IQueryable<User> m) => m.GetEnumerator()).Returns(() => usersData.GetEnumerator());
//mockContext.Setup(c => c.Users).Returns(mockUserSet.Object);
var service = new DoctorsController(mockContext.Object);
return(service);
}
public async Task AddDoctorAppointment_Returns_ViewResult_WhenModelNotValid()
{
IFixture fixture = new Fixture();
fixture.Behaviors.Add(new OmitOnRecursionBehavior());
var model = fixture.Create <AddDoctorAbsenceViewModel>();
var doctorsController = new DoctorsController(_appService.Object)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, "user") },
"test"))
}
}
};
doctorsController.ModelState.AddModelError("errorkey", "Error");
var action = await doctorsController.AddDoctorAbsence(model);
Assert.IsInstanceOf <ViewResult>(action);
}
private static void WorkWithDoctor()
{
var service = _serviceProvider.GetRequiredService <IService <Doctor, int> >();
var controller = new DoctorsController(service);
controller.Start();
}
//[TestMethod]
//[TestCategory("Index")]
public void ShouldCheckResultFromDoctorsControllerIndexIsNotNull()
{
_doctorsController = new DoctorsController(_doctorRepository);
var value = _doctorsController.Index() as ViewResult;
Assert.IsNotNull(value);
}
public DoctorsControllerTests()
{
controller = new DoctorsController(repository.Object,
specialtyRepository.Object,
specialtyGetter.Object,
positionRepository.Object,
diplomaRepository.Object);
}
public DoctorsControllerTest()
{
var fixture = new Fixture();
doctorServiceMock = fixture.Freeze <Mock <IDoctorService> >();
mapper = fixture.Freeze <Mock <IMapper> >();
doctorController = new DoctorsController(doctorServiceMock.Object, mapper.Object);
}
public void Delete_Valid_Detail()
{
DoctorRep loandata = new DoctorRep(db);
DoctorsController obj = new DoctorsController(loandata);
var data = obj.Delete(1);
var okResult = data as OkObjectResult;
Assert.AreEqual(200, okResult.StatusCode);
}
public void GetDetailTest()
{
DoctorRep res = new DoctorRep(db);
DoctorsController obj = new DoctorsController(res);
var data = obj.Get1(1);
var okResult = data as ObjectResult;
Assert.AreEqual(200, okResult.StatusCode);
}
public void ShouldCheckTypeOfInstanceResultAfterCreateFromDoctorsController()
{
_doctorsController = new DoctorsController(_doctorRepository);
var expectedType = typeof(ViewResult);
var value = _doctorsController.Create();
Assert.IsInstanceOfType(value, expectedType);
}
public void GetDetailsTest()
{
var res = new Mock <DoctorRep>(db);
DoctorsController obj = new DoctorsController(res.Object);
var data = obj.Get();
var okResult = data as OkObjectResult;
Assert.AreEqual(200, okResult.StatusCode);
}
public void ShouldCheckTypeOfInstanceResultAfterCreateFromDoctorsController_WithFakeRepository()
{
_doctorsController = new DoctorsController(_fakeDoctorRepository);
var expectedType = typeof(ActionResult);
var value = _doctorsController.Create(new Doctor());
Assert.IsInstanceOfType(value, expectedType);
}
public void Create()
{
// Arrange
DoctorsController controller = new DoctorsController();
// Act
ViewResult result = controller.Create() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Delete(int?id)
{
// Arrange
DoctorsController controller = new DoctorsController();
// Act
ViewResult result = controller.Delete(id) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void Update_Valid_Detail()
{
Doctor doc = new Doctor {
Name = "Dummy 3", Email = "DD", Password = "******"
};
DoctorRep res = new DoctorRep(db);
DoctorsController obj = new DoctorsController(res);
var data = obj.Put(1, doc);
var okResult = data as OkObjectResult;
Assert.AreEqual(200, okResult.StatusCode);
}
public void ShouldCheckTypeOfInstanceResultAfterDeleteConfirmedFromDoctorsController_WithMock()
{
var doctor = new Doctor();
var service = new Mock <IDoctorRepository>();
service.Setup(x => x.GetDoctorById(1)).Returns(doctor);
_doctorsController = new DoctorsController(service.Object);
var expectedType = typeof(RedirectToRouteResult);
var value = _doctorsController.DeleteConfirmed(1);
Assert.IsInstanceOfType(value, expectedType);
}
public void Add_Valid_Detail()
{
var res = new Mock <DoctorRep>(db);
DoctorsController obj = new DoctorsController(res.Object);
Doctor doc = new Doctor {
Name = "Dummy 3", Email = "DD", Password = "******"
};
var data = obj.Post(doc);
//var okResult = data as OkObjectResult;
Assert.AreEqual("added", data);
}
public void ShouldCheckResultFromDoctorsControllerEdit_WithMock()
{
var doctor = new Doctor();
var service = new Mock <IDoctorRepository>();
service.Setup(x => x.GetDoctorById(1)).Returns(doctor);
_doctorsController = new DoctorsController(service.Object);
var expected = doctor;
var result = _doctorsController.Edit(1);
var actual = ((ViewResult)result).Model as Doctor;
Assert.AreEqual(actual, expected);
}
public void ShouldCheckResultStatusCodeWhenDoctorIdIsWrongFromDoctorsControllerDetails_WithMock()
{
var doctor = new Doctor();
var service = new Mock <IDoctorRepository>();
service.Setup(x => x.GetDoctorById(1)).Returns(doctor);
_doctorsController = new DoctorsController(service.Object);
var expectedErrorCode = 404;
var result = _doctorsController.Details(1000000);
var viewResult = (HttpNotFoundResult)result;
var actual = viewResult.StatusCode;
Assert.AreEqual(expectedErrorCode, actual);
}
public void TestInitialize()
{
_configMock = new Mock <IConfigurationManager>();
_configMock.Setup(c => c.GetDoctors).Returns("GetDoctors");
_configMock.Setup(c => c.GetSpecialtiesByDoctorId).Returns("GetSpecialtiesByDoctorId");
_configMock.Setup(c => c.RdssqlServerConnection).Returns("RdssqlServerConnection");
_configMock.Setup(c => c.SqlQueryPath).Returns("path");
_fileMock = new Mock <IFileReader>();
_fileMock.Setup(f => f.GetFile("GetDoctors")).Returns("GetDoctors");
_fileMock.Setup(f => f.GetFile("GetSpecialtiesByDoctorId")).Returns("GetSpecialtiesByDoctorId");
_dapperMock = new Mock <IDapper>();
_factoryMock = new Mock <IFactory>();
_factoryMock.Setup(f => f.Files).Returns(_fileMock.Object);
_factoryMock.Setup(f => f.WebConfig).Returns(_configMock.Object);
_factoryMock.Setup(f => f.Dapper).Returns(_dapperMock.Object);
_controller = new DoctorsController(_factoryMock.Object);
}
public async Task GetById_DoctorId_ReturnsNotFound_withNewMock()
{
// Arrange
var doctorServiceMock1 = new Mock <IDoctorService>();
var mapper1 = new Mock <IMapper>();
Doctor docotr = new Doctor {
Id = 1
};
mapper1.Setup(m => m.Map <ReadDoctorDto>(docotr))
.Returns(null as ReadDoctorDto);
doctorServiceMock1.Setup(p => p.GetDoctorByIdAsync(docotr.Id))
.ReturnsAsync(null as Doctor);
var doctorController1 = new DoctorsController(doctorServiceMock1.Object, mapper1.Object);
// Act
var actualResult = await doctorController1.GetAsync(docotr.Id);
// Assert
Assert.True(actualResult is NotFoundResult);
doctorServiceMock1.Verify(m => m.GetDoctorByIdAsync(docotr.Id), Times.Once);
}
public DoctorTesting()
{
_doctorService = new DoctorHerlperService();
_doctorControl = new DoctorsController(_doctorService);
}
public void Setup()
{
_logger = A.Fake <ILogger <DoctorsController> >();
_doctors = GetTestDoctors();
_doctorsController = new DoctorsController(_logger);
}
public void CleanupTests()
{
_doctorRepository = null;
_doctorsController = null;
}
