public void TestInitialize()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
_context = new ApplicationDbContext(options);
drivers.Add(new Driver {
Id = 10, FirstName = "Ryan", LastName = "Vickers", DateOfBirth = new DateTime(2001, 07, 05), Address = "Sideroad 25", City = "Meaford", Province = "Ontario", PostalCode = "N461W3", LicenseNumber = "V1000G7DHF44VVD", LicenseExpiry = System.DateTime.Now, DriverPhoto = "Bruh.png"
});
drivers.Add(new Driver {
Id = 11, FirstName = "Jake", LastName = "Hoppers", DateOfBirth = new DateTime(1987, 11, 07), Address = "Lakeview Dirve", City = "Collingwood", Province = "Ontario", PostalCode = "H1WDW9", LicenseNumber = "HDJAKG7DHF44VVD", LicenseExpiry = new DateTime(2021, 12, 15), DriverPhoto = "Bruh.png"
});
drivers.Add(new Driver {
Id = 12, FirstName = "Nathan", LastName = "Long", DateOfBirth = new DateTime(1991, 09, 12), Address = "MapleStreet", City = "Toronto", Province = "Ontario", PostalCode = "DJA3MD", LicenseNumber = "IWM3WG7DHF44VVD", LicenseExpiry = new DateTime(2023, 11, 07), DriverPhoto = "Bruh.png"
});
foreach (var p in drivers)
{
_context.Drivers.Add(p);
}
_context.SaveChanges();
controller = new DriversController(_context);
}
void LoadDrvAndContragents()
{
using RegistrantCoreContext ef = new RegistrantCoreContext();
DriversController driver = new DriversController();
cb_drivers.ItemsSource = driver.GetDriversCurrent();
}
private static void WorkWithDriver()
{
var service = _serviceProvider.GetRequiredService <IService <Driver, int> >();
var controller = new DriversController(service);
controller.Start();
}
public async Task GetAll_Sucess()
{
var mock = new Mock <IDriverService>();
DriversController controller = new DriversController(mock.Object);
var result = await controller.GetAll();
mock.Verify(service => service.GetAllAsync(), Times.AtLeastOnce());
}
public async Task GetDriver_OneDriver_Succeeds()
{
// Arrange
Driver driver = DriverGenerator.Driver;
var driversController = new DriversController(Mock.Of <IDriversRepository>(pr => pr.Get(1) == Task.FromResult(driver)));
// Act
var driverRetrieved = await driversController.GetDriver(1);
// Assert
driverRetrieved.Value.Should().Be(driver);
}
public async Task GetById_Sucess()
{
Guid request = new Guid();
var mock = new Mock <IDriverService>();
mock.Setup(service => service.GetByIdAsync(It.IsAny <DriverId>()));
DriversController controller = new DriversController(mock.Object);
var result = await controller.GetGetById(request);
mock.Verify(service => service.GetByIdAsync(It.IsAny <DriverId>()), Times.AtLeastOnce());
}
public void SearchDriverTest()
{
var id = 123;
var driver = GetEmptyDriver(id);
_repositoryMock.Get(Arg.Any <int>()).Returns(driver);
_unitOfWorkMock.Drivers.Returns(_repositoryMock);
var controller = new DriversController(_unitOfWorkMock);
var response = controller.Get(id);
Assert.AreEqual(driver.Code, response.Code);
}
public async Task PostDriver_ReturnsDriver_Succeeds()
{
// Arrange
var driversRepositoryMock = new Mock <IDriversRepository>();
Driver driver = DriverGenerator.Driver;
driversRepositoryMock.Setup(pr => pr.Create(driver)).ReturnsAsync(true);
var driversController = new DriversController(driversRepositoryMock.Object);
// Act
var result = await driversController.Post(driver);
// Assert
((CreatedAtActionResult)result.Result).Value.Should().Be(driver);
}
public async void DriversController_GetById_Empty()
{
// Arrange
var mockDriverId = 10;
var mockDriver = MockDriverData.GetSingleEmptyModelAsync();
var mockDriverService = new MockDriverService().MockGetById(mockDriver);
var mockLogging = new Mock <ILogger <DriversController> >();
var controller = new DriversController(mockDriverService.Object, mockLogging.Object);
// Act
var result = await controller.Get(mockDriverId);
// Assert
result.Should().BeOfType <NotFoundResult>();
}
public async Task GetDrivers_AllDrivers_Succeeds()
{
// Arrange
var driversRepositoryMock = new Mock <IDriversRepository>();
var expectedDrivers = new List <Driver>();
driversRepositoryMock.Setup(d => d.GetAll()).ReturnsAsync(expectedDrivers);
var driversController = new DriversController(driversRepositoryMock.Object);
// Act
var driverRetrieved = await driversController.GetDriver();
// Assert
((OkObjectResult)driverRetrieved.Result).Value.Should().BeSameAs(expectedDrivers);
}
public void ListDriversByAdminTest()
{
var listResponse = new List <Driver>();
var driver = GetEmptyDriver(123);
listResponse.Add(driver);
_repositoryMock.GetDriverByAdministrator(Arg.Any <int>()).Returns(listResponse);
_unitOfWorkMock.Drivers.Returns(_repositoryMock);
var controller = new DriversController(_unitOfWorkMock);
var output = controller.GetAdminVehicles(123);
CollectionAssert.AreEquivalent(listResponse, output.ToList());
}
public async Task GetAll_Sucess()
{
var mockRepository = new Mock <IDriverRepository>();
mockRepository.Setup(repository => repository.GetAllAsync()).Returns(Task.FromResult(new List <Driver>()));
var mockUnit = new Mock <IUnitOfWork>();
DriverService driverService = new DriverService(mockUnit.Object, mockRepository.Object);
DriversController controller = new DriversController(driverService);
var result = await controller.GetAll();
mockRepository.Verify(repository => repository.GetAllAsync(), Times.AtLeastOnce());
Assert.IsInstanceOfType(result, typeof(ActionResult <IEnumerable <DriverDto> >));
}
public async void DriversController_GetById_Valid()
{
// Arrange
var mockDriverId = 13;
var mockDriver = MockDriverData.GetSingleModelAsync();
var mockDriverService = new MockDriverService().MockGetById(mockDriver);
var mockLogging = new Mock <ILogger <DriversController> >();
var controller = new DriversController(mockDriverService.Object, mockLogging.Object);
// Act
var result = await controller.Get(mockDriverId);
// Assert
Assert.IsAssignableFrom <IActionResult>(result);
mockDriverService.VerifyGetById(Times.Once());
}
public async Task Post_NormalParameters_Sucess()
{
CreatingDriverDto request = new CreatingDriverDto("DriverA10", "lalala", 876263907, 14352011, 227012657, 927638614, 3495566307, new string[] { "Driver:1", "Driver:2", "Driver:3" }, 1128724707, 0);
var mock = new Mock <IDriverService>();
mock.Setup(service => service.AddAsync(It.IsAny <DriverDto>())).Returns(Task.FromResult(DriverMapper.toDTO(request)));
DriversController controller = new DriversController(mock.Object);
var result = await controller.Create(request);
mock.Verify(service => service.AddAsync(It.IsAny <DriverDto>()), Times.AtLeastOnce());
ActionResult <DriverDto> driverDto = DriverMapper.toDTO(request);
Assert.IsInstanceOfType(result, typeof(ActionResult <DriverDto>));
}
public async void DriversController_GetAll_Valid()
{
// Arrange
var mockDriver = MockDriverData.GetAllModelListAsync();
DriversResourceParameters parameters = new DriversResourceParameters {
};
var mockDriverService = new MockDriverService().MockGetAll(mockDriver);
var mockLogging = new Mock <ILogger <DriversController> >();
var controller = new DriversController(mockDriverService.Object, mockLogging.Object);
// Act
var result = await controller.Get(parameters);
// Assert
Assert.IsAssignableFrom <IActionResult>(result);
mockDriverService.VerifyGetAll(Times.Once());
}
public async Task GetById_NormalId_Sucess()
{
Guid id = new Guid();
var mockRepository = new Mock <IDriverRepository>();
mockRepository.Setup(repository => repository.GetByIdAsync(It.IsAny <DriverId>()));
var mockUnit = new Mock <IUnitOfWork>();
DriverService driverService = new DriverService(mockUnit.Object, mockRepository.Object);
DriversController controller = new DriversController(driverService);
var result = await controller.GetGetById(id);
mockRepository.Verify(repository => repository.GetByIdAsync(It.IsAny <DriverId>()), Times.AtLeastOnce());
Assert.IsInstanceOfType(result, typeof(ActionResult <DriverDto>));
}
public async Task DeleteAsync_WithExistingGuid_SendsCommandAndReturnsOk()
{
// Arrange
var guid = Guid.NewGuid();
var mediator = new Mock <IMediator>();
mediator
.Setup(m => m.Send(It.Is <DeleteDriverCommand>(q => q.DriverId == guid), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(Unit.Value))
.Verifiable();
var controller = new DriversController(mediator.Object);
// Act
var response = await controller.DeleteAsync(guid);
// Assert
mediator.Verify();
Assert.IsType <OkResult>(response);
}
public async Task Drivers_Post_Test_Correct()
{
Driver driver = new Driver()
{
FullName = "Вася пупкін два",
PassportNum = "123456789",
DriverLicenseNum = "ФФФ123456",
ADRCertificate = true,
DriversWagons = null
};
var mockRepo = new Mock <IRepository>();
var controller = new DriversController(mockRepo.Object);
Task <ActionResult <Driver> > result = controller.PostDriver(driver);
//Assert
Assert.True(controller.ModelState.IsValid);
Assert.NotNull(result.Id);
}
public async Task Drivers_Put_Test_Correct()
{
Driver driverWithChanges = new Driver()
{
Id = 1,
FullName = "Вася пупкін два",
PassportNum = "123456789",
DriverLicenseNum = "ФФФ123456",
ADRCertificate = true,
DriversWagons = null
};
var mockRepo = new Mock <IRepository>();
var controller = new DriversController(mockRepo.Object);
controller.PutDriver(driverWithChanges.Id, driverWithChanges);
//Assert
Assert.True(controller.ModelState.IsValid);
}
public async Task Drivers_Post_Test_InCorrect_values()
{
Driver driver = new Driver()
{
FullName = "21321312fgcvВася пупкін два",
PassportNum = "123456789sadsadsads",
DriverLicenseNum = "ФФФ123456fdsfdsfds",
ADRCertificate = true,
DriversWagons = null
};
var mockRepo = new Mock <IRepository>();
var controller = new DriversController(mockRepo.Object);
Task <ActionResult <Driver> > result = controller.PostDriver(driver);
//Assert
Assert.False(controller.ModelState.IsValid);
Assert.Equal(controller.ModelState.ErrorCount, 3);
Assert.Null(result.Id);
}
public async Task Drivers_Put_Test_InCorrect_values()
{
Driver driverWithChanges = new Driver()
{
Id = 1,
FullName = "ВасяAAAAAAgdsgfdsfdsfsdf",
PassportNum = "123456789aaa",
DriverLicenseNum = "ФФФ123456aaa",
ADRCertificate = true,
DriversWagons = null
};
var mockRepo = new Mock <IRepository>();
var controller = new DriversController(mockRepo.Object);
controller.PutDriver(driverWithChanges.Id, driverWithChanges);
//Assert
Assert.Equal(controller.ModelState.ErrorCount, 3);
}
public async Task ListAsync_WithNoSorting_SendsQueryAndReturnsOk()
{
// Arrange
IEnumerable <ViewDriverDto> expectedResult = new ViewDriverDto[] { };
var mediator = new Mock <IMediator>();
mediator
.Setup(m => m.Send(It.Is <ListDriversQuery>(q => q.OrderBy == ListDriversQuery.Sorting.FirstName), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(expectedResult))
.Verifiable();
var controller = new DriversController(mediator.Object);
// Act
var response = await controller.ListAsync("");
// Assert
mediator.Verify();
Assert.IsType <OkObjectResult>(response.Result);
Assert.Equal(expectedResult, ((OkObjectResult)response.Result).Value);
}
public async Task PostAsync_WithData_SendsCommandAndReturnsOk()
{
// Arrange
var data = new ModifyDriverDto {
};
var mediator = new Mock <IMediator>();
mediator
.Setup(m => m.Send(It.Is <CreateDriverCommand>(q => q.DriverDto == data), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(Unit.Value))
.Verifiable();
var controller = new DriversController(mediator.Object);
// Act
var response = await controller.PostAsync(data);
// Assert
mediator.Verify();
Assert.IsType <OkResult>(response);
}
public async Task DeleteAsync_WithNonExistingGuid_SendsCommandAndReturnsNotFound()
{
// Arrange
var guid = Guid.NewGuid();
var mediator = new Mock <IMediator>();
mediator
.Setup(m => m.Send(It.Is <DeleteDriverCommand>(q => q.DriverId == guid), It.IsAny <CancellationToken>()))
.Returns(Task.FromException <Unit>(new NotFoundException("Just not found")))
.Verifiable();
var controller = new DriversController(mediator.Object);
// Act
var response = await controller.DeleteAsync(guid);
// Assert
mediator.Verify();
Assert.IsType <NotFoundObjectResult>(response);
Assert.Equal("Just not found", ((NotFoundObjectResult)response).Value);
}
public async void DriversController_GetAll_Empty()
{
// Arrange
var mockDriver = MockDriverData.GetEmptyModelListAsync();
DriversResourceParameters parameters = new DriversResourceParameters {
};
var mockDriverService = new MockDriverService().MockGetAll(mockDriver);
var mockLogging = new Mock <ILogger <DriversController> >();
var controller = new DriversController(mockDriverService.Object, mockLogging.Object);
// Act
var result = await controller.Get(parameters);
// Assert
var okResult = result.Should().BeOfType <OkObjectResult>().Subject;
var Driver = okResult.Value.Should().BeAssignableTo <IEnumerable <DriverDto> >().Subject;
Driver.Count().Should().Be(0);
mockDriverService.VerifyGetAll(Times.Once());
}
public async Task Post_NormalParameters_Sucess()
{
CreatingDriverDto creatingDriverDto = new CreatingDriverDto("DriverA10", "lalala", 876263907, 14352011, 227012657, 927638614, 3495566307000, new string[] { "Driver:1", "Driver:2", "Driver:3" }, 1128724707, 0);
DriverDto driverDto = DriverMapper.toDTO(creatingDriverDto);
Driver driver = DriverMapper.toDomain(driverDto);
var mockRepository = new Mock <IDriverRepository>();
mockRepository.Setup(repository => repository.AddAsync(It.IsAny <Driver>())).Returns(Task.FromResult(driver));
var mockUnit = new Mock <IUnitOfWork>();
DriverService driverService = new DriverService(mockUnit.Object, mockRepository.Object);
DriversController controller = new DriversController(driverService);
var result = await controller.Create(creatingDriverDto);
mockRepository.Verify(repository => repository.AddAsync(It.IsAny <Driver>()), Times.AtLeastOnce());
mockUnit.Verify(unit => unit.CommitAsync(), Times.AtLeastOnce());
Assert.IsInstanceOfType(result, typeof(ActionResult <DriverDto>));
}
public async Task GetDriversTest()
{
var mockRepo = new Mock <IRepository>();
mockRepo.Setup(repo => repo.Drivers.FindAsync(It.IsAny <int>()))
.ReturnsAsync(new Driver()
{
Id = 1,
FullName = "Вася пупкін два",
PassportNum = "123456789",
DriverLicenseNum = "ФФФ123456",
ADRCertificate = true,
DriversWagons = null
}).Verifiable();
var controller = new DriversController(mockRepo.Object);
// Act
var result = controller.GetDriver(1);
Assert.NotNull(result);
}
public async Task GetAsync_WithExistingGuid_SendsQueryAndReturnsOk()
{
// Arrange
var guid = Guid.NewGuid();
var expectedResult = new ViewDriverDto {
};
var mediator = new Mock <IMediator>();
mediator
.Setup(m => m.Send(It.Is <GetDriverQuery>(q => q.DriverId == guid), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(expectedResult))
.Verifiable();
var controller = new DriversController(mediator.Object);
// Act
var response = await controller.GetAsync(guid);
// Assert
mediator.Verify();
Assert.IsType <OkObjectResult>(response.Result);
Assert.Equal(expectedResult, ((OkObjectResult)response.Result).Value);
}
