public ActionResult New()
{
BaseModelVehicleService modelToAdd = new VehicleModelService();
var viewModel = modelToAdd.New();
return(View("NewVehicleModelForm", viewModel));
}
private List <SelectListItem> GetVehicleModel()
{
VehicleModelFilter filter = new VehicleModelFilter();
filter.Name = "";
return(VehicleModelService.Get(filter).Select(b => new SelectListItem(b.Name, b.Id.ToString())).ToList());
}
public ActionResult Index(string sortOrder, string searchString, int?page)
{
BaseModelVehicleService models = new VehicleModelService();
var modelsToDisplay = models.Index(sortOrder, searchString, page);
return(View(modelsToDisplay.ToPagedList(page ?? 1, 5)));
}
// GET: VehicleModelController/Edit/5
public ActionResult Edit(int id)
{
var item = VehicleModelService.GetById(id);
ViewBag.VehicleBrands = GetVehicleBrand();
return(View(item));
}
public async Task GetPagedList_Success()
{
List <VehicleModel> vehicleModelList = new List <VehicleModel>
{
new VehicleModel {
Id = 2, MakeId = 1, Name = "X2", Abrv = "x2"
},
new VehicleModel {
Id = 3, MakeId = 2, Name = "X1", Abrv = "x1"
}
};
var filter = new Filter
{
Search = null,
IsAscending = false,
PageNumber = 1,
TotalCount = 2
};
modelRepository.Setup(x => x.GetPagedModel(filter))
.ReturnsAsync(new StaticPagedList <VehicleModel>(vehicleModelList,
filter.PageNumber, filter.PageSize, filter.TotalCount));
var vehicleModelService = new VehicleModelService(modelRepository.Object);
var result = await vehicleModelService.PagedList(filter);
result.Should().NotBeNull();
result.PageNumber.ShouldBeEquivalentTo(1);
result.TotalItemCount.ShouldBeEquivalentTo(2);
result.ToList().Count().ShouldBeEquivalentTo(2);
}
public async void FindModelAsync_Returns_PagedList_Models()
{
var sortMock = new Mock <ISortingParams>();
var filterMock = new Mock <IFilteringParams>();
var pageMock = new Mock <IPagingParams>();
var pagedListMock = new Mock <IPagedList <IVehicleModel> >();
pagedListMock.Setup(s => s.Count).Returns(10);
pagedListMock.Setup(s => s.PageNumber).Returns(10);
pagedListMock.Setup(s => s.PageSize).Returns(10);
pagedListMock.Setup(s => s.TotalItemCount).Returns(10);
repoMock.Setup(s => s.FindModelAsync(It.IsAny <IFilteringParams>(),
It.IsAny <ISortingParams>(),
It.IsAny <IPagingParams>()))
.Returns(Task.FromResult(pagedListMock.Object));
uowMock.SetupGet(s => s.Models).Returns(repoMock.Object);
var modelService = new VehicleModelService(uowMock.Object);
var result = await modelService.FindModelAsync(filterMock.Object, sortMock.Object, pageMock.Object);
//Assert
Assert.Equal(10, result.TotalItemCount);
Assert.Equal(10, result.Count);
Assert.Equal(10, result.PageSize);
Assert.Equal(10, result.PageNumber);
}
public void ReturnCorrectCities()
{
// Arrange
var expectedModels = new List <VehicleModel>()
{
new VehicleModel()
{
Id = 1, Name = "Test 1"
},
new VehicleModel()
{
Id = 2, Name = "Test 2"
},
new VehicleModel()
{
Id = 3, Name = "Test 3"
}
}.AsQueryable();
var mockedVehicleModelRepository = new Mock <IEfGenericRepository <VehicleModel> >();
var mockedEfProvider = new Mock <IEfCarAdvertsDataProvider>();
mockedVehicleModelRepository.Setup(x => x.All()).Returns(expectedModels);
mockedEfProvider.Setup(p => p.VehicleModels).Returns(mockedVehicleModelRepository.Object);
var vehicleModelService = new VehicleModelService(mockedEfProvider.Object);
// Act
var result = vehicleModelService.All();
// Assert
Assert.AreEqual(result, expectedModels);
}
public ActionResult Delete(int id)
{
BaseModelVehicleService modelToDelete = new VehicleModelService();
modelToDelete.Delete(id);
return(RedirectToAction("Index", "VehicleModels"));
}
public ActionResult Save(VehicleModel vehiclemodel)
{
BaseModelVehicleService modelToSave = new VehicleModelService();
modelToSave.Save(vehiclemodel);
return(RedirectToAction("Index", "VehicleModels"));
}
public void GetById_Should_NotBeCalled_IfNotCalledYolo()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
// Assert
mockedDbSet.Verify(rep => rep.GetById(1), Times.Never);
}
public void GetAllVehicleModels_Should_NotBeCalled_IfItIsNeverCalled()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
// Assert
mockedDbSet.Verify(rep => rep.All(), Times.Never);
}
public void Constructor_Should_CreateVehicleModelService_IfParamsAreValid()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
// Assert
Assert.That(vehicleModelService, Is.InstanceOf <VehicleModelService>());
}
public ActionResult Index()
{
VehicleModelFilter filter = new VehicleModelFilter();
filter.Name = "";
var items = VehicleModelService.Get(filter);
return(View(items));
}
public async void UpdateAsync_InvalidParameters_ReturnsMinus4()
{
var repository = new Mock <IVehicleModelRepository>();
var classForTesting = new VehicleModelService(repository.Object);
var result = await classForTesting.UpdateAsync(Guid.NewGuid(), Guid.Empty, "test", "test");
result.Should().Be(-4);
}
public async void DeleteAsync_Success_Returns0()
{
var repository = new Mock <IVehicleModelRepository>();
var classForTesting = new VehicleModelService(repository.Object);
var result = await classForTesting.DeleteAsync(Guid.NewGuid());
result.Should().Be(0);
}
public void GetById_ShouldThrowNullReferenceException_IfVehicleModelIsNull()
{
// Arrange & Act
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
Mock <VehicleModel> vehicleModelThatIsNull = null;
// Assert
Assert.Throws <NullReferenceException>(() => vehicleModelService.GetById(vehicleModelThatIsNull.Object.Id));
}
public async void AddAsync_validParameters_ReturnsNull()
{
var repository = new Mock <IVehicleModelRepository>();
var classForTesting = new VehicleModelService(repository.Object);
var result = await classForTesting.AddAsync(Guid.NewGuid(), Guid.NewGuid(), "test", "test");
result.Should().Be(0);
}
public void ConstructorShould_ReturnNewInstanceOfVehicleModel_IfParameterIsValid()
{
// Arrange
var mockedEfProvider = new Mock <IEfCarAdvertsDataProvider>();
// Act
var vehicleModel = new VehicleModelService(mockedEfProvider.Object);
// Assert
Assert.That(vehicleModel, Is.Not.Null);
}
public async void AddAsync_InvalidParameters_ReturnsMinus3()
{ //arrange
var repository = new Mock <IVehicleModelRepository>();
var classForTesting = new VehicleModelService(repository.Object);
//3. test
var result = await classForTesting.AddAsync(Guid.Empty, Guid.NewGuid(), "test", "test");
result.Should().Be(-3);
}
public async Task Delete_Success()
{
var vehicleModel = new VehicleModel {
Id = 5, MakeId = 3, Name = "306", Abrv = "306"
};
modelRepository.Setup(x => x.DeleteAsync(vehicleModel.Id)).ReturnsAsync(1);
var vehicleModelService = new VehicleModelService(modelRepository.Object);
var result = await vehicleModelService.DeleteAsync(vehicleModel.Id);
result.ShouldBeEquivalentTo(1);
}
public async Task Create_Success()
{
var newVehicleModel = new VehicleModel {
Id = 5, MakeId = 3, Name = "306", Abrv = "306"
};
modelRepository.Setup(x => x.InsertAsync(It.IsAny <VehicleModel>())).ReturnsAsync(1);
var vehicleModelService = new VehicleModelService(modelRepository.Object);
var result = await vehicleModelService.CreateAsync(newVehicleModel);
result.ShouldBeEquivalentTo(1);
}
public ActionResult Edit(int id)
{
BaseModelVehicleService modelToEdit = new VehicleModelService();
var vehicleModelToEdit = modelToEdit.Edit(id);
if (vehicleModelToEdit == null)
{
return(HttpNotFound());
}
return(View("EditVehicleModelForm", vehicleModelToEdit));
}
public void GetById_Should_NotReturnVehicleModel_IfThereIsNoVehicleModelYolo()
{
// Arrange
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
// Act
mockedDbSet.Setup(rep => rep.GetById(0)).Returns(() => null);
// Assert
Assert.IsNull(vehicleModelService.GetById(0));
}
public async void GetModelAsync_Returns_IVehicleModel()
{
repoMock.Setup(s => s.GetAsync(It.IsAny <Guid>())).Returns(Task.FromResult(new Mock <IVehicleModel>().Object));
uowMock.SetupGet(s => s.Models).Returns(repoMock.Object);
var modelService = new VehicleModelService(uowMock.Object);
var model = await modelService.GetModelAsync(Guid.NewGuid());
//Assert
Assert.NotNull(model);
Assert.IsAssignableFrom <IVehicleModel>(model);
}
public void GetAllVehicleModels_Should_BeCalled_IfParamsAreValid()
{
// Arrange
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
// Act
vehicleModelService.GetAllVehicleModels();
// Assert
mockedDbSet.Verify(rep => rep.All(), Times.Once);
}
public ActionResult Delete(int id, IFormCollection collection)
{
try
{
Response response = VehicleModelService.Delete(id);
ViewBag.Response = response;
}
catch
{
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
public void GetById_Should_Work_IfCalledWithValidParams()
{
// Arrange
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
var vehicleModelWithId = new Mock <VehicleModel>();
// Act
mockedDbSet.Setup(rep => rep.GetById(vehicleModelWithId.Object.Id)).Returns(() => vehicleModelWithId.Object);
// Assert
Assert.AreEqual(vehicleModelService.GetById(vehicleModelWithId.Object.Id), vehicleModelWithId.Object);
}
public async void RemoveModelAsync_Returns_1()
{
repoMock.Setup(s => s.RemoveAsync(It.IsAny <Guid>())).Returns(Task.FromResult(1));
uowMock.SetupGet(s => s.Models).Returns(repoMock.Object);
uowMock.Setup(s => s.CommitAsync()).Returns(Task.FromResult(1));
var modelService = new VehicleModelService(uowMock.Object);
var result = await modelService.RemoveModelAsync(Guid.NewGuid());
//Assert
Assert.Equal(1, result);
}
public void GetById_Should_ReturnTheProperVehicleModelWithId_IfCalled()
{
// Arrange
var mockedDbSet = new Mock <IEfCarSystemDbSetCocoon <VehicleModel> >();
var vehicleModelService = new VehicleModelService(mockedDbSet.Object);
var vehicleModelWithId = new Mock <VehicleModel>();
// Act
mockedDbSet.Setup(rep => rep.GetById(vehicleModelWithId.Object.Id)).Returns(() => vehicleModelWithId.Object);
// Assert
Assert.IsInstanceOf <VehicleModel>(vehicleModelService.GetById(vehicleModelWithId.Object.Id));
}
public async void UpdateModelAsync_Returns_1()
{
repoMock.Setup(s => s.UpdateAsync(It.IsAny <IVehicleModel>()));
uowMock.SetupGet(s => s.Models).Returns(repoMock.Object);
uowMock.Setup(s => s.CommitAsync()).Returns(Task.FromResult(1));
var modelService = new VehicleModelService(uowMock.Object);
var result = await modelService.UpdateModelAsync(new Mock <IVehicleModel>().Object);
//Assert
Assert.Equal(1, result);
}
