public async void create()
{
var vehicleServiceMock = new Mock <IVehicleService>();
var vehicleTypeServiceMock = new Mock <IVehicleTypeService>();
string registration = "AA11AA";
string vin = "123456789AAAAAAAA";
string entranceDate = "27/01/1978";
string vehicleType = "vehicleType1";
var vehicle = new Vehicle(registration, vin, entranceDate, vehicleType);
var vehicleTypeDTO = new VehicleTypeDTO("vehicleType1", "description", 123, "Gasolina", 30, 12, 15);
var vehicleDTO = new VehicleDTO(vehicle.Id.AsGuid(), registration, vin, entranceDate, vehicleType);
vehicleTypeServiceMock.Setup(_ => _.GetVehicleTypeByID("vehicleType1")).ReturnsAsync(vehicleTypeDTO);
vehicleServiceMock.Setup(_ => _.AddVehicle(vehicleDTO)).ReturnsAsync(vehicleDTO);
var controller = new VehicleController(vehicleServiceMock.Object, vehicleTypeServiceMock.Object);
var actual = await controller.Create(vehicleDTO);
Assert.NotNull(actual);
Assert.NotNull(actual.Result);
}
public void CreateVehicleNullAttributesTest()
{
VehicleDTO vehicle = new VehicleDTO();
vehicle.Brand = null;
vehicle.Model = null;
vehicle.Color = null;
vehicle.Type = null;
vehicle.Vin = null;
UserDTO user = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(user);
var mockVehicleService = new Mock <VehicleService>();
mockVehicleService.Setup(vs => vs.AddVehicle(vehicle)).Throws(new VehicleNullAttributesException());
VehicleController vehicleController = new VehicleController(mockUserService.Object, mockVehicleService.Object, null);
vehicleController.Request = createUserControllerRequest();
addTokenHeaderToRequest(vehicleController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)vehicleController.Create(vehicle);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public void Vehicle_Exit_OneHourAnd15_ShouldBe_Ok()
{
//arrange
_repositoryVehicle.Clear();
VehicleController vehicleController = new VehicleController(_mediator);
vehicleController.Create(VehicleMother.CreateCommand).ConfigureAwait(false).GetAwaiter().GetResult();
_repositoryVehicle.FirstOrDefault().AmountPaid = null;
_repositoryVehicle.FirstOrDefault().TotalTimeInParking = null;
_repositoryVehicle.FirstOrDefault().TotalTimePaid = null;
_repositoryVehicle.FirstOrDefault().Price = 0;
_repositoryVehicle.FirstOrDefault().CameIn = _repositoryVehicle.FirstOrDefault().CameIn.AddMinutes(-75);
//action
ObjectResult result = (ObjectResult)vehicleController.PatchClient(VehicleMother.UpdateCommand).ConfigureAwait(false).GetAwaiter().GetResult();
//verify
result.StatusCode.Should().Be(200);
_repositoryVehicle.Count.Should().Be(expected: 1);
result.Value.Should().Be(Unit.Successful);
_vehicleRepositoryMock.Verify(v => v.CreateAsync(It.IsAny <Vehicle>()));
_vehicleRepositoryMock.Verify(v => v.GetByPlateAsync(VehicleMother.ValidNoExited.Plate));
_vehicleRepositoryMock.Verify(v => v.GetByPlateAsync(VehicleMother.CreateCommand.Plate));
_vehicleRepositoryMock.Verify(v => v.UpdateAsync(It.IsAny <Vehicle>()));
_vehicleRepositoryMock.VerifyNoOtherCalls();
_repositoryVehicle.FirstOrDefault().Price.Should().Be(expected: PriceMother.Price.Value);
_repositoryVehicle.FirstOrDefault().TotalTimePaid.Should().Be(expected: $"2 hrs");
_repositoryVehicle.FirstOrDefault().AmountPaid.Should().Be(expected: $"R$ {PriceMother.Price.Value + PriceMother.Price.Additional}");
}
public async Task CanCreateVehicleTestAsync()
{
//Arrange
TestApplicationDbContext tdb = new TestApplicationDbContext();
Vehicle vehicleToBeCreated = new Vehicle
{
Title = "Nissan Micra",
Price = 1250,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
//creating a controller
VehicleController controller = new VehicleController(tdb);
//Act
//call controller searchIndexMethod
var result = await controller.Create(vehicleToBeCreated);
//var result = viewResult.ViewData.Model as IEnumerable<VehicleModel>;
//Assert
//we are checking that a view called Index is returned
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
//view Result for the cannot create
}
public void CreateTestReturn200()
{
FormModel formModel = new()
{
VehicleNumbers = "RP-1223",
YearOfProduction = 2010
};
var result = vehicleController.Create(formModel);
Assert.IsInstanceOf <OkObjectResult>(result.Result);
}
public void Vehicle_Add_WithoutPrice_SholdBe_Exception()
{
//arrange
VehicleController vehicleController = new VehicleController(_mediator);
//action
ObjectResult result = (ObjectResult)vehicleController.Create(VehicleMother.CreateCommandDuplicatePlate).ConfigureAwait(false).GetAwaiter().GetResult();
//verify
result.StatusCode.Should().Be((int)ErrorCodes.AlreadyExists);
result.Value.Should().BeOfType <ExceptionPayload>();
_vehicleRepositoryMock.Verify(v => v.GetByPlateAsync(VehicleMother.CreateCommandDuplicatePlate.Plate));
_vehicleRepositoryMock.VerifyNoOtherCalls();
}
public void Vehicle_Add_ShouldBe_Ok()
{
//arrange
VehicleController vehicleController = new VehicleController(_mediator);
//action
ObjectResult result = (ObjectResult)vehicleController.Create(VehicleMother.CreateCommand).ConfigureAwait(false).GetAwaiter().GetResult();
//verify
result.StatusCode.Should().Be(200);
_repositoryVehicle.Count.Should().Be(expected: 1);
result.Value.Should().Be(VehicleMother.ValidNoExited.Id);
_vehicleRepositoryMock.Verify(v => v.GetByPlateAsync(VehicleMother.CreateCommand.Plate));
_vehicleRepositoryMock.Verify(v => v.CreateAsync(It.IsAny <Vehicle>()));
_vehicleRepositoryMock.VerifyNoOtherCalls();
}
public void VehicleControllerCreateReturnsView_ExpectedSuccess()
{
// Arrange
Mock <IVehicleLogic> mockVehicleLogic = new Mock <IVehicleLogic>();
mockVehicleLogic.Setup(x => x.GetVehiclesOwned(It.IsAny <Int32>())).ReturnsAsync(GetVehicles());
var controllerUnderTest = new VehicleController(_context, mockVehicleLogic.Object);
var model = new Vehicle();
controllerUnderTest.ModelState.AddModelError("error", "Invalid post.");
// Act
var result = controllerUnderTest.Create(model);
// Assert
var viewResult = Assert.IsType <Task <IActionResult> >(result);
}
public async Task Vehicle_Create_VehicleId()
{
//setup
var position = new Vehicle()
{
VehicleId = 2,
VehicleBrand = "VW",
VehicleModel = "Jetta",
DateOfManufacturing = new DateTime(2017, 02, 03),
VehicleColor = "Burgundy Metallic",
VehicleType = "FWD",
Engine = "1.4 TSI, 150HP",
Fuel = "Gasoline"
};
_vehicleRepository.Setup(x => x.Create(It.IsAny <Vehicle>())).Callback(() =>
{
_vehicle.Add(position);
}).Returns(() => Task <Vehicle> .Factory.StartNew(() => new Vehicle()
{
VehicleId = 2,
VehicleBrand = "Porsche",
VehicleModel = "Panamera",
DateOfManufacturing = new DateTime(2017, 02, 03),
VehicleColor = "Blue Metallic",
VehicleType = "AWD",
Engine = "Turbo 4.0, 549HP",
Fuel = "Gasoline"
}));
//Act
var result = await _controller.Create(_mapper.Map <VehicleRequest>(position));
//Assert
var okObjectResult = result as OkObjectResult;
Assert.NotNull(okObjectResult);
var pos = okObjectResult.Value as VehicleResponse;
Assert.NotNull(pos);
Assert.NotNull(_vehicle.FirstOrDefault(x => x.VehicleId == position.VehicleId));
}
public async Task CannotDuplicateVehicleTestAsync()
{
//Arrange
//creating the fake vehicle that I'll try duplicate, tdb = test database
TestApplicationDbContext tdb = new TestApplicationDbContext();
Vehicle vehicleToNotBeDuplicated = new Vehicle
{
Description = "Vehicle with same description",
Title = "Nissan Micra",
Price = 1500,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
Vehicle vehicleToTryDuplicate = new Vehicle
{
Description = "Vehicle with same description",
Title = "Nissan Micra",
Price = 1250,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
//adding the vehicles to the "fake" database
//I shouldn't be able to do this
tdb.Vehicles.Add(vehicleToTryDuplicate);
//creating a controller
VehicleController controller = new VehicleController(tdb);
//Act
//call controller searchIndexMethod
var result = await controller.Create(vehicleToNotBeDuplicated);
//var result = viewResult.ViewData.Model as IEnumerable<VehicleModel>;
//Assert
//we are checking that a view called Index is returned
Assert.IsInstanceOfType(result, typeof(ViewResult));
//view Result for the cannot create
}
public async void Create_Errors()
{
VehicleControllerMockFacade mock = new VehicleControllerMockFacade();
var mockResponse = new Mock <CreateResponse <ApiVehicleServerResponseModel> >(null as ApiVehicleServerResponseModel);
var mockRecord = new ApiVehicleServerResponseModel();
mockResponse.SetupGet(x => x.Success).Returns(false);
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiVehicleServerRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiVehicleServerResponseModel> >(mockResponse.Object));
VehicleController controller = new VehicleController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Create(new ApiVehicleServerRequestModel());
response.Should().BeOfType <ObjectResult>();
(response as ObjectResult).StatusCode.Should().Be((int)HttpStatusCode.UnprocessableEntity);
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiVehicleServerRequestModel>()));
}
public void CreateVehicleSuccessfullyTest()
{
VehicleDTO vehicle = CreateVehicle();
UserDTO user = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(user);
var mockVehicleService = new Mock <VehicleService>();
mockVehicleService.Setup(vs => vs.AddVehicle(vehicle)).Verifiable();
VehicleController vehicleController = new VehicleController(mockUserService.Object, mockVehicleService.Object, null);
vehicleController.Request = createUserControllerRequest();
addTokenHeaderToRequest(vehicleController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)vehicleController.Create(vehicle);
Assert.AreEqual(HttpStatusCode.Created, response.Response.StatusCode);
}
public async void Create_No_Errors()
{
VehicleControllerMockFacade mock = new VehicleControllerMockFacade();
var mockResponse = ValidationResponseFactory <ApiVehicleServerResponseModel> .CreateResponse(null as ApiVehicleServerResponseModel);
mockResponse.SetRecord(new ApiVehicleServerResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiVehicleServerRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiVehicleServerResponseModel> >(mockResponse));
VehicleController controller = new VehicleController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
IActionResult response = await controller.Create(new ApiVehicleServerRequestModel());
response.Should().BeOfType <CreatedResult>();
(response as CreatedResult).StatusCode.Should().Be((int)HttpStatusCode.Created);
var createResponse = (response as CreatedResult).Value as CreateResponse <ApiVehicleServerResponseModel>;
createResponse.Record.Should().NotBeNull();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiVehicleServerRequestModel>()));
}
