public void Should_not_create_or_update_vehicle_on_post_put_when_provided_invalid_make()
{
//Arrange
var _vehicleRepo = new Mock <IRepository <VehicleModel> >();
var id = Guid.NewGuid();
var post = new PostVehicleModel()
{
Make = null,
Model = "test model",
Odometer = 0,
Plate = "test plate",
VehicleType = VehicleTypeEnum.Electric,
Year = 0,
};
_controller = new VehiclesController(_vehicleRepo.Object, _serviceRepo.Object);
//Act
var result = JsonConvert.DeserializeObject <ResultModel>(_controller.Post(post));
var result1 = JsonConvert.DeserializeObject <ResultModel>(_controller.Put(post.ToVehicleModel()));
//Assert
Assert.True(result.IsError);
Assert.True(result1.IsError);
}
public void Should_create_or_update_vehicle_on_post_put_when_provided_valid_post_vehicle()
{
//Arrange
var _vehicleRepo = new Mock <IRepository <VehicleModel> >();
_vehicleRepo.Setup(moq => moq.Read()).Returns(new System.Collections.Generic.List <VehicleModel>()
{
new VehicleModel()
{
Plate = "test"
}
});
var id = Guid.NewGuid();
var post = new PostVehicleModel()
{
Make = "test make",
Model = "test model",
Odometer = 0,
Plate = "test plate",
VehicleType = VehicleTypeEnum.Electric,
Year = 0,
};
_controller = new VehiclesController(_vehicleRepo.Object, _serviceRepo.Object);
//Act
var result = JsonConvert.DeserializeObject <ResultModel>(_controller.Post(post));
var result1 = JsonConvert.DeserializeObject <ResultModel>(_controller.Put(post.ToVehicleModel()));
//Assert
Assert.False(result.IsError);
Assert.False(result1.IsError);
}
public void Should_delete_vehicle_on_delete_when_given_valid_vehicle_id()
{
//Arrange
var _vehicleRepo = new Mock <IRepository <VehicleModel> >();
var id = Guid.NewGuid();
_vehicleRepo.Setup(setup => setup.Read()).Returns(new System.Collections.Generic.List <VehicleModel>()
{
new VehicleModel()
{
Id = id
}
});
_serviceRepo.Setup(setup => setup.Read()).Returns(new System.Collections.Generic.List <ServiceModel> {
new ServiceModel {
ProviderId = Guid.NewGuid()
}
});
_controller = new VehiclesController(_vehicleRepo.Object, _serviceRepo.Object);
//Act
var result = JsonConvert.DeserializeObject <ResultModel>(_controller.Delete(id.ToString()));
//Assert
_vehicleRepo.Verify(mock => mock.Remove(It.IsAny <VehicleModel>()));
}
public void Should_not_delete_vehicle_on_delete_when_vehicle_being_used_in_service()
{
//Arrange
var _vehicleRepo = new Mock <IRepository <VehicleModel> >();
var id = Guid.NewGuid();
_vehicleRepo.Setup(setup => setup.Read()).Returns(new System.Collections.Generic.List <VehicleModel>()
{
new VehicleModel()
{
Id = Guid.NewGuid()
}
});
_serviceRepo.Setup(setup => setup.Read()).Returns(new System.Collections.Generic.List <ServiceModel> {
new ServiceModel {
ProviderId = id
}
});
_controller = new VehiclesController(_vehicleRepo.Object, _serviceRepo.Object);
//Act
var result = JsonConvert.DeserializeObject <ResultModel>(_controller.Delete(Guid.NewGuid().ToString()));
//Assert
Assert.True(result.IsError);
}
public void Setup()
{
var builder = new ConfigurationBuilder()
.AddJsonFile("testsettings.json", false, true)
.AddEnvironmentVariables();
_configuration = builder.Build();
//string connStr =_configuration.GetConnectionString("LorryLogAPIContext");
string testData = _configuration.GetSection("TestFiles")["vehicle"];
//var options = new DbContextOptionsBuilder<LorryLogAPIContext>()
// .UseSqlServer(connStr)
// .Options;
var options = new DbContextOptionsBuilder <LorryLogAPIContext>()
.UseInMemoryDatabase(databaseName: "LorryLog")
.Options;
_context = new LorryLogAPIContext(options);
_controller = new VehiclesController(_context);
string testPath = Path.GetDirectoryName(Path.GetDirectoryName(TestContext.CurrentContext.TestDirectory)) + testData;
string json = File.ReadAllText(testPath);
testTrucks = JsonSerializer.Deserialize <List <Vehicle> >(json);
}
public async void AddVehicle_ReturnVehicleCreated()
{
// Arrange
var mockRepo = new Mock <IVehicleCatalogRepository>();
mockRepo.Setup(repo => repo.SaveAll())
.Returns(Task.FromResult <bool>(true));
var mapper = _dependencyFixture.ServiceProvider.GetService <IMapper>();
var logger = Mock.Of <ILogger <VehiclesController> >();
var controller = new VehiclesController(mockRepo.Object, mapper, logger);
VehicleForNew newVehicle = new VehicleForNew()
{
value = 18000.50M,
brandId = 1,
modelId = 1,
yearModel = 1998,
fuel = "Gasoline"
};
// Act
var result = await controller.Post(newVehicle);
// Assert
var okResult = Assert.IsType <CreatedAtRouteResult>(result);
var returnValue = Assert.IsType <string>(okResult.Value);
Assert.Equal("Vehicle created.", returnValue);
}
public void PostWithMissingVehicleResultsInBadRequest()
{
var mock = new Mock <IVehicleRepositorical>();
var controller = new VehiclesController(mock.Object);
var result = controller.Post(null);
var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);
}
public async void Delete_WhenNotFound()
{
// arrange
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Delete(It.IsAny <Guid>()))
.ReturnsAsync(() => ResultCode.NotFound);
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Delete(TestVehicle().Id);
var notFoundResult = result as NotFoundResult;
// assert
Assert.NotNull(notFoundResult);
}
public async void Post_WhenConflict()
{
// arrange
var testVehicle = TestVehicleModel();
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Insert(It.IsAny <Vehicle>()))
.ReturnsAsync(() => new Result <Guid>(ResultCode.Conflict, testVehicle.Id));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Post(testVehicle);
var conflictResult = result as StatusCodeResult;
// assert
Assert.Equal(409, conflictResult.StatusCode);
}
public async void Put_WhenNotValid()
{
// arrange
var testVehicle = TestVehicleModel();
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Update(It.IsAny <Vehicle>()))
.ReturnsAsync(() => new Result <Guid>(ResultCode.BadRequest, testVehicle.Id));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Put(testVehicle.Id, testVehicle);
var badRequestResult = result as BadRequestResult;
// assert
Assert.NotNull(badRequestResult);
}
public void ShouldBeConstructed()
{
var service = new Mock <IVehicleService>();
var controller = new VehiclesController(service.Object);
Assert.NotNull(controller);
}
public async void Post_WhenValid()
{
// arrange
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Insert(It.IsAny <Vehicle>()))
.ReturnsAsync(() => new Result <Guid>(ResultCode.Success, TestVehicle().Id));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Post(TestVehicleModel());
var createdAtRouteResult = result as CreatedAtRouteResult;
// assert
Assert.NotNull(createdAtRouteResult);
}
public void Put_UpdatesVehicleProperties()
{
var vehicles = new List <Vehicle>
{
new Vehicle {
Id = 1, RegistrationNumber = "1"
},
}.AsQueryable();
var vehiclesMockSet = MockDbSetHelper.CreateMockSet(vehicles);
var mockContext = new Mock <InstantDeliveryContext>();
mockContext.Setup(c => c.Vehicles).Returns(vehiclesMockSet.Object);
var controller = new VehiclesController(mockContext.Object);
var selected = vehiclesMockSet.Object.FirstOrDefault();
vehiclesMockSet.Object.Attach(selected);
selected.RegistrationNumber = "2";
var vehicleDto = Mapper.Map <VehicleDto>(selected);
controller.Put(vehicleDto);
var result = vehiclesMockSet.Object.FirstOrDefault();
Assert.Equal(result?.RegistrationNumber, "2");
}
public async void Get_WithBadId()
{
// arrange
var targetId = Guid.Empty;
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Get(It.IsAny <Guid>()))
.ReturnsAsync(() => new Result <Vehicle>(ResultCode.Success, TestVehicle()));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Get(targetId);
var badRequestResult = result as BadRequestObjectResult;
// assert
Assert.NotNull(badRequestResult);
}
public async void QueryVehicleList_ReturnsVehiclesAscendingByValue(int modelId)
{
// Arrange
var mockRepo = new Mock <IVehicleCatalogRepository>();
mockRepo.Setup(repo => repo.GetVehicles(modelId))
.Returns(Task.FromResult <IEnumerable <Vehicle> >(new List <Vehicle>()
{
new Vehicle()
{
Id = 1, Value = 15488.45M, BrandId = 1, ModelId = modelId, YearModel = 1998, Fuel = "Gasoline"
},
new Vehicle()
{
Id = 2, Value = 18484.54M, BrandId = 1, ModelId = modelId, YearModel = 1996, Fuel = "Gasoline"
},
new Vehicle()
{
Id = 3, Value = 10000.00M, BrandId = 1, ModelId = modelId, YearModel = 1997, Fuel = "Gasoline"
},
}.OrderBy(o => o.Value)));
var mapper = _dependencyFixture.ServiceProvider.GetService <IMapper>();
var logger = Mock.Of <ILogger <VehiclesController> >();
var controller = new VehiclesController(mockRepo.Object, mapper, logger);
// Act
var result = await controller.GetVehicles(modelId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <List <VehicleForList> >(okResult.Value);
var topVehicle = returnValue.FirstOrDefault().value;
Assert.Equal("R$ 10.000,00", topVehicle);
}
public void CreateVehicleTest()
{
var vehicleController = new VehiclesController(repository);
//var repo = new EfCoreVehicleRepository();
var vehicle = new Vehicle();
vehicle.LicensePlate = "CJ-10-NTE";
vehicle.Details = "Testing";
vehicle.Status = "In tests";
var client = new HttpClient {
BaseAddress = new Uri(ServiceBaseURL)
};
var jsonVehicle = JsonConvert.SerializeObject(vehicle);
var payload = new StringContent(jsonVehicle, Encoding.UTF8, "application/json");
var _responseB = client.GetAsync("api/vehicles").Result;
var responseResultB = JsonConvert.DeserializeObject <List <Vehicle> >(_responseB.Content.ReadAsStringAsync().Result);
client.PostAsync("api/vehicles", payload);
var _responseA = client.GetAsync("api/vehicles").Result;
var responseResultA = JsonConvert.DeserializeObject <List <Vehicle> >(_responseA.Content.ReadAsStringAsync().Result);
Assert.IsTrue(responseResultB.Count > 0);
Assert.IsTrue(responseResultA.Count > 0);
Assert.AreNotEqual(responseResultA, responseResultB);
}
public async Task checkInVehicle()
{
VehiclesController vc = new VehiclesController();
Random random = new Random();
Array tikcets = Enum.GetValues(typeof(TICKET_TYPE));
TICKET_TYPE ticketType = TICKET_TYPE.VIP;
Array vehicles = Enum.GetValues(typeof(VehicleType));
VehicleType vehicleType = (VehicleType)vehicles.GetValue(random.Next(0, vehicles.Length - 1));
long licensePlateID = random.Next(0, 100) * 1000 + random.Next(0, 100);
Vehicle vehicleToCheckIn = new Vehicle("test" + random.Next(0, 100),
licensePlateID,
054 * 1000 + random.Next(0, 100).ToString(),
vehicleType,
ticketType,
random.Next(0, 2),
random.Next(0, 2),
random.Next(0, 2)
);
IHttpActionResult result = await vc.checkInVehicle(vehicleToCheckIn);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(CreatedAtRouteNegotiatedContentResult <Vehicle>));
Assert.IsNotNull((result as CreatedAtRouteNegotiatedContentResult <Vehicle>).Content);
Assert.AreNotEqual <int>(0, (result as CreatedAtRouteNegotiatedContentResult <Vehicle>).Content.LotNumber);
}
public void BeforeEachTest()
{
var vehiclesManager = new Mock <IVehiclesManager>();
var vehiclesRepository = new Mock <IReadRepository <Vehicle> >();
_unitUnderTests = new VehiclesController(vehiclesManager.Object, vehiclesRepository.Object);
}
public VehiclesController Setup()
{
var list = new List <Vehicle>
{
new Vehicle {
ID = 1, LicensePlate = "123", Brand = "Jeep", Model = "Renegade", Doors = 5, Owner = "Pedrito"
},
new Vehicle {
ID = 2, LicensePlate = "3245", Brand = "Jeep", Model = "Compass", Doors = 5, Owner = "Pedrito2"
},
new Vehicle {
ID = 3, LicensePlate = "4567", Brand = "Jeep", Model = "Wrangler", Doors = 3, Owner = "Pedrito3"
},
}.AsQueryable();
var set = new Mock <DbSet <Vehicle> >();
set.As <IQueryable <Vehicle> >().Setup(m => m.Provider).Returns(list.Provider);
set.As <IQueryable <Vehicle> >().Setup(m => m.Expression).Returns(list.Expression);
set.As <IQueryable <Vehicle> >().Setup(m => m.ElementType).Returns(list.ElementType);
set.As <IQueryable <Vehicle> >().Setup(m => m.GetEnumerator()).Returns(list.GetEnumerator());
var context = new Mock <ApplicationDbContext>();
context.Setup(c => c.Vehicles).Returns(set.Object);
var controller = new VehiclesController(context.Object);
return(controller);
}
public void Should_Get_By_Id_Fail()
{
var controller = new VehiclesController(vehicleStorage.Object, logger.Object);
var result = controller.Get(new Guid());
Assert.False(result != null, "Get By Id Test failed for fail case");
}
public void Should_Get_By_Id()
{
var controller = new VehiclesController(vehicleStorage.Object, logger.Object);
var result = controller.Get(new Guid(id));
Assert.True(result != null, "Get By Id Test failed");
}
public async void GetAll_WhenNotFound()
{
// arrange
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.GetAll())
.ReturnsAsync(() => new Result <IEnumerable <Vehicle> >(ResultCode.NotFound));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.GetAll();
var notFoundResult = result as NotFoundResult;
// assert
Assert.NotNull(notFoundResult);
}
public async void Get_WhenNotFound()
{
// arrange
var targetId = Guid.NewGuid();
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Get(It.IsAny <Guid>()))
.ReturnsAsync(() => new Result <Vehicle>(ResultCode.NotFound));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Get(targetId);
var notFoundResult = result as NotFoundResult;
// assert
Assert.Equal(404, notFoundResult.StatusCode);
}
public async void GetAll_ReturnsData()
{
// arrange
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.GetAll())
.ReturnsAsync(() => new Result <IEnumerable <Vehicle> >(ResultCode.Success, TestVehicles()));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
dataStructureConverterMoq.Setup(x => x.ConvertAndMap <IEnumerable <VehicleModel>, IEnumerable <Vehicle> >(It.IsAny <string>(), It.IsAny <IEnumerable <Vehicle> >()))
.Returns(new Dictionary <string, object>
{
{ "vehicles", TestVehicles() }
});
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.GetAll();
var okResult = result as OkObjectResult;
var response = okResult.Value as Dictionary <string, object>;
// assert
Assert.NotNull(response.Values);
}
public async void Get_ReturnsData()
{
// arrange
var targetId = IdentifierHelper.VehicleId;;
var errorCodeConverter = new ErrorCodeConverter();
var vehicleServiceMoq = new Mock <IVehicleService>();
vehicleServiceMoq.Setup(x => x.Get(It.IsAny <Guid>()))
.ReturnsAsync(() => new Result <Vehicle>(ResultCode.Success, TestVehicle()));
var dataStructureConverterMoq = new Mock <IDataStructureConverter>();
dataStructureConverterMoq.Setup(x => x.ConvertAndMap <VehicleModel, Vehicle>(It.IsAny <string>(), It.IsAny <Vehicle>()))
.Returns(new Dictionary <string, object>
{
{ "vehicle", VehicleHelper.Get() }
});
var sut = new VehiclesController(vehicleServiceMoq.Object, errorCodeConverter, dataStructureConverterMoq.Object)
{
ControllerContext = DefaultControllerContext()
};
// act
var result = await sut.Get(targetId);
var okResult = result as OkObjectResult;
var response = okResult.Value as Dictionary <string, object>;
// assert
Assert.NotNull(response.Values);
}
public void UpdateVehicleTest()
{
var vehicleController = new VehiclesController(repository);
//var repo = new EfCoreVehicleRepository();
var vehicle = new Vehicle();
vehicle.Id = 2;
vehicle.LicensePlate = "CJ-10-UPP";
vehicle.Details = "Testing update";
vehicle.Status = "In tests";
var client = new HttpClient {
BaseAddress = new Uri(ServiceBaseURL)
};
var jsonVehicle = JsonConvert.SerializeObject(vehicle);
var payload = new StringContent(jsonVehicle, Encoding.UTF8, "application/json");
client.PutAsync("api/vehicles/2", payload);
var _response = client.GetAsync("api/vehicles/2").Result;
var responseResult = JsonConvert.DeserializeObject <Vehicle>(_response.Content.ReadAsStringAsync().Result);
Assert.IsNotNull(responseResult);
Assert.AreEqual(vehicle.Id, responseResult.Id);
Assert.AreEqual(vehicle.LicensePlate, responseResult.LicensePlate);
Assert.AreEqual(vehicle.Details, responseResult.Details);
Assert.AreEqual(vehicle.Status, responseResult.Status);
}
public void PutVehicleWithNewVehicleIdResultsInCreate()
{
var mock = new Mock <IVehicleRepositorical>();
mock.Setup(m => m.FindById(It.Is <string>(s => s == "2"))).Returns(default(Vehicle));
Vehicle newVehicle = null;
mock.Setup(m => m.AddNewVehicle(It.Is <string>(s => s == "2"), It.IsAny <Vehicle>()))
.Callback((string i, Vehicle p) => { newVehicle = p; });
var controller = new VehiclesController(mock.Object)
{
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
var result = controller.Put("2", new Vehicle {
VehicleIdentifier = "name 2", VehicleIdentifier = "10.1"
});
var createdAtRouteResult = Assert.IsType <CreatedAtRouteResult>(result);
var Vehicle = Assert.IsType <Vehicle>(createdAtRouteResult.Value);
Assert.Equal("name 2", Vehicle.VehicleIdentifier);
Assert.Equal("10.1", Vehicle.VehicleIdentifier);
Assert.NotNull(newVehicle);
}
public void PutVehicleWithNewVehicleIdResultsInCreate()
{
var mock = new Mock <IVehicleRepositorical>();
mock.Setup(m => m.FindById(It.Is <string>(s => s == "2")))
.Returns(default(Vehicle));
Vehicle newVehicle = null;
mock.Setup(m => m.AddNewVehicle(It.Is <string>(s => s == "2"), It.IsAny <Vehicle>()))
.Callback((string _, Vehicle p) => { newVehicle = p; });
var controller = new VehiclesController(mock.Object)
{
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
var result = controller.Put("2", new VehicleInfo
{
ModelIdentifier = "name 2", VehicleIdentifier = "10.1"
});
var createdAtRouteResult = Assert.IsType <CreatedAtRouteResult>(result);
var vehicleInfo = Assert.IsType <VehicleInfo>(createdAtRouteResult.Value);
Assert.Equal("name 2", vehicleInfo.ModelIdentifier);
Assert.Equal("10.1", vehicleInfo.VehicleIdentifier);
Assert.NotNull(newVehicle);
//Assert.Equal((int) HttpStatusCode.MethodNotAllowed, createdAtRouteResult.StatusCode);
//Assert.True(controller.Response.Headers.ContainsKey("Allow"));
//Assert.Equal(new[] {"GET", "POST"},
// controller.Response.Headers["Allow"].Select(e => e)
// .Select(e => e.Split(", ", StringSplitOptions.RemoveEmptyEntries)).SelectMany(e => e).ToArray());
}
public async Task TestVehicleController_GetCarsByCarOwner()
{
using (var transaction = Fixture.Connection.BeginTransaction())
{
using (var context = Fixture.CreateContext(transaction))
{
using var serviceScope = _serviceProvider.CreateScope();
var appEnvirontent = serviceScope.ServiceProvider.GetRequiredService <IWebHostEnvironment>();
var seed = new SeedData(new VehicleImageRetriever(), appEnvirontent);
var userManager = serviceScope.ServiceProvider.GetRequiredService <ICustomUserManager>();
var userRoleManager = serviceScope.ServiceProvider.GetRequiredService <ICustomRoleManager>();
await seed.Initialize(userManager, userRoleManager, context);
var carsRepo = new CarsRepository(context);
var carOwnerRepo = new CarOwnersRepository(context);
var identitySevice = new Mock <IIdentityService>();
var carService = new CarService(carsRepo, carOwnerRepo, identitySevice.Object);
var carOwnerService = new CarOwnerService(carOwnerRepo);
var mockLogger = new Mock <ILogger <VehiclesController> >();
ILogger <VehiclesController> logger = mockLogger.Object;
var mockWebHostingEnvironment = new Mock <IWebHostEnvironment>();
var mockCustomAuthorizationService = new Mock <ICustomAuthorizationService>();
mockCustomAuthorizationService
.Setup(m => m.AuthorizeAsync(
It.IsAny <ClaimsPrincipal>(),
It.IsAny <object>(),
It.IsAny <IAuthorizationRequirement>())
).ReturnsAsync(AuthorizationResult.Success);
var controller = new VehiclesController(
carService,
logger,
new UriService("https://localhost:5010"),
new CustomMapper(
new VehicleImageRetriever()),
mockWebHostingEnvironment.Object,
new VehicleImageRetriever(),
mockCustomAuthorizationService.Object
);
Random rnd = new Random();
var index = rnd.Next(0, context.Users.AsNoTracking().ToHashSet().Count);
var owner = context.Users.AsNoTracking().ToList()[index];
var resJson = JsonConvert.SerializeObject(owner);
var deserializedOwner = JsonConvert.DeserializeObject <OwnerRequest>(resJson);
var res = await controller.GetCarsByCarOwner(deserializedOwner);
Assert.NotNull(res);
Assert.IsAssignableFrom <OkObjectResult>(res);
}
}
}
public void Get_Test()
{
quotesProviderMock.Setup(q => q.GetQuoteSubset(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(new List <QuoteSubsetModel>());
var controller = new VehiclesController(quotesProviderMock.Object);
var result = controller.Get();
Assert.IsNotNull(result);
}
