public void Edit_POST_GivenModelStateIsValid_ShouldCallUpdate()
{
//---------------Set up test pack-------------------
var viewModel = Substitute.For <CarPartsViewModel>();
var repository = Substitute.For <ICarPartRepository>();
var mapperEngine = Substitute.For <IMappingEngine>();
var carPart1 = new CarPartBuilder().WithNewId().Build();
var carPart = new CarPartBuilder().WithNewId().Build();
mapperEngine.Map <CarPart>(viewModel).Returns(carPart);
repository.GetCarPartBy(viewModel.CarPartId).Returns(carPart);
repository.Update(carPart, carPart1);
var carPartsController = CreateBuilder()
.WithCarPartRepository(repository)
.WithMappingEngine(mapperEngine)
.Build();
//---------------Assert Precondition----------------
Assert.IsTrue(carPartsController.ModelState.IsValid);
//---------------Execute Test ----------------------
var result = carPartsController.Edit(viewModel);
//---------------Test Result -----------------------
repository.Received().Update(carPart, carPart1);
}
public void Edit_POST_GivenModelStateIsValid_ShouldRedirectToRouteResult()
{
//---------------Set up test pack-------------------
var viewModel = Substitute.For <CarPartsViewModel>();
var repository = Substitute.For <ICarPartRepository>();
var mapperEngine = Substitute.For <IMappingEngine>();
var carPart1 = new CarPartBuilder().WithNewId().Build();
var carPart = new CarPartBuilder().WithNewId().Build();
mapperEngine.Map <CarPart>(viewModel).Returns(carPart);
repository.GetCarPartBy(viewModel.CarPartId).Returns(carPart);
repository.Update(carPart, carPart1);
var carPartsController = CreateBuilder()
.WithCarPartRepository(repository)
.WithMappingEngine(mapperEngine)
.Build();
//---------------Assert Precondition----------------
Assert.IsTrue(carPartsController.ModelState.IsValid);
//---------------Execute Test ----------------------
var result = carPartsController.Edit(viewModel) as RedirectToRouteResult;
//---------------Test Result -----------------------
Assert.IsNotNull(result);
var routeValue = result.RouteValues["action"];
Assert.AreEqual("Index", routeValue);
}
public void Create_POST_ShouldReturnToAction()
{//---------------Set up test pack-------------------
var viewModel = Substitute.For <CarPartsViewModel>();
var repository = Substitute.For <ICarPartRepository>();
var mapperEngine = Substitute.For <IMappingEngine>();
var car = new CarPartBuilder().WithNewId().Build();
mapperEngine.Map <CarPart>(viewModel).Returns(car);
var carPartsController = CreateBuilder()
.WithCarPartRepository(repository)
.WithMappingEngine(mapperEngine)
.Build();
repository.Save(car);
//---------------Assert Precondition----------------
Assert.IsTrue(carPartsController.ModelState.IsValid);
//---------------Execute Test ----------------------
var result = carPartsController.Create(viewModel) as RedirectToRouteResult;
//---------------Test Result -----------------------
Assert.IsNotNull(result);
var actionName = result.RouteValues["action"];
Assert.AreEqual("Index", actionName);
}
public void Index_GivenAllUsersReturnedFromRepository_ShouldReturnViewModel()
{
//---------------Set up test pack-------------------
var car = new CarBuilder().WithNewId().Build();
var part = new PartBuilder().WithNewId().Build();
var carPart = new CarPartBuilder().WithNewId().WithCar(car).WithPart(part).Build();
var carParts = new List <CarPart> {
carPart
};
var repository = Substitute.For <ICarPartRepository>();
var mappingEngine = ResolveMapper();
repository.GetCarPart().Returns(carParts);
var partController = CreateBuilder()
.WithCarPartRepository(repository)
.WithMappingEngine(mappingEngine)
.Build();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = partController.Index() as ViewResult;
//---------------Test Result -----------------------
Assert.IsNotNull(result);
var model = result.Model as List <CarPartsIndexViewModel>;
Assert.IsInstanceOf <List <CarPartsIndexViewModel> >(model);
Assert.AreEqual(carPart.CarPartId, model.FirstOrDefault().CarPartId);
Assert.AreEqual(carPart.CarId, model.FirstOrDefault().CarId);
Assert.AreEqual(carPart.PartId, model.FirstOrDefault().PartId);
Assert.AreEqual(carPart.Quantity, model.FirstOrDefault().Quantity);
}
public void Save_GivenNewCarPart_ShouldSave()
{
//---------------Set up test pack-------------------
var car = new CarPartBuilder().WithNewId().BuildSaved();
var userRepository = new CarPartRepository();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
userRepository.Save(car);
//---------------Test Result -----------------------
}
public void Delete_GivenExistingCarPart_ShouldDeleteAndSave()
{
//---------------Set up test pack-------------------
var carPart = new CarPartBuilder().WithNewId().BuildSaved();
var carParts = Broker.GetBusinessObjectCollection <CarPart>("");
var userRepository = new CarPartRepository();
Assert.AreEqual(1, carParts.Count);
//---------------Execute Test ----------------------
userRepository.Delete(carPart);
//---------------Test Result -----------------------
Assert.AreEqual(0, carParts.Count);
}
public void Update_GivenExistingCarPart_ShouldUpdateAndSave()
{
//---------------Set up test pack-------------------
var existingPart = new CarPartBuilder().WithNewId().BuildSaved();
var userRepository = new CarPartRepository();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
userRepository.Update(existingPart, existingPart);
var parts = Broker.GetBusinessObjectCollection <CarPart>("");
//---------------Test Result -----------------------
Assert.AreEqual(1, parts.Count);
}
public void GetParts_GivenThreeCarParts_ShouldReturnCarParts()
{
//---------------Set up test pack-------------------
var part1 = new CarPartBuilder().WithNewId().BuildSaved();
var part2 = new CarPartBuilder().WithNewId().BuildSaved();
var part3 = new CarPartBuilder().WithNewId().BuildSaved();
var userRepository = new CarPartRepository();
var cars = new List <CarPart> {
part1, part2, part3
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = userRepository.GetCarPart();
//---------------Test Result -----------------------
Assert.AreEqual(result.Count, cars.Count);
}
public void Edit_POST_GivenModelStateIsInValid_ShouldReturnView()
{
//---------------Set up test pack-------------------
var viewModel = Substitute.For <CarPartsViewModel>();
var repository = Substitute.For <ICarPartRepository>();
var mapperEngine = Substitute.For <IMappingEngine>();
var partRepository = Substitute.For <IPartRepository>();
var carRepository = Substitute.For <ICarRepository>();
var part = new PartBuilder().Build();
var car = new CarBuilder().Build();
var parts = new List <TestHabanero.BO.Part> {
part
};
var cars = new List <Car> {
car
};
partRepository.GetParts().Returns(parts);
carRepository.GetCars().Returns(cars);
var carPart1 = new CarPartBuilder().WithNewId().Build();
var carPart = new CarPartBuilder().WithNewId().Build();
mapperEngine.Map <CarPart>(viewModel).Returns(carPart);
repository.GetCarPartBy(viewModel.CarPartId).Returns(carPart);
repository.Update(carPart, carPart1);
var carPartsController = CreateBuilder()
.WithCarPartRepository(repository)
.WithMappingEngine(mapperEngine)
.WithCarRepository(carRepository)
.WithPartRepository(partRepository)
.Build();
carPartsController.ModelState.AddModelError("IdNotValid", "Car Id is not valid");
//---------------Assert Precondition----------------
Assert.IsFalse(carPartsController.ModelState.IsValid);
//---------------Execute Test ----------------------
var result = carPartsController.Edit(viewModel) as ViewResult;
//---------------Test Result -----------------------
Assert.IsNotNull(result);
var model = result.Model as CarPartsViewModel;
Assert.IsInstanceOf <CarPartsViewModel>(model);
Assert.AreEqual(viewModel, model);
}
public void GetCarPartBy_GivenCarPartId_ShouldReturnCarPart()
{
//---------------Set up test pack-------------------
var part = new CarPartBuilder().WithNewId().BuildSaved();
var userRepository = new CarPartRepository();
var parts = new List <CarPart> {
part
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = userRepository.GetCarPartBy(part.CarPartId);
//---------------Test Result -----------------------
Assert.AreEqual(result.CarPartId, parts.FirstOrDefault().CarPartId);
var actual = parts.First();
Assert.AreSame(part, actual);
}
public void GetCarParts_GivenOneCarPart_ShouldReturnCarPart()
{
//---------------Set up test pack-------------------
var car = new CarPartBuilder().WithNewId().BuildSaved();
var userRepository = new CarPartRepository();
var cars = new List <CarPart> {
car
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = userRepository.GetCarPart();
//---------------Test Result -----------------------
Assert.AreEqual(result.Count, cars.Count);
var actual = cars.First();
Assert.AreSame(car, actual);
}
public void Edit_Get_ShouldReturnViewWithCarViewModel()
{
//---------------Set up test pack-------------------
var car = new CarBuilder().WithNewId().Build();
var part = new PartBuilder().WithNewId().Build();
var carPart = new CarPartBuilder().WithNewId().WithCar(car).WithPart(part).Build();
var id = carPart.CarPartId;
var carPartRepository = Substitute.For <ICarPartRepository>();
var partRepository = Substitute.For <IPartRepository>();
var carRepository = Substitute.For <ICarRepository>();
var mapper = Substitute.For <IMappingEngine>();
var viewModel = Substitute.For <CarPartsViewModel>();
carPartRepository.GetCarPartBy(id).Returns(carPart);
var parts = new List <TestHabanero.BO.Part> {
part
};
var cars = new List <Car> {
car
};
partRepository.GetParts().Returns(parts);
carRepository.GetCars().Returns(cars);
mapper.Map <CarPartsViewModel>(carPart).Returns(viewModel);
var carController = CreateBuilder()
.WithCarPartRepository(carPartRepository)
.WithCarRepository(carRepository)
.WithPartRepository(partRepository)
.WithMappingEngine(mapper)
.Build();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = carController.Edit(id) as ViewResult;
//---------------Test Result -----------------------
Assert.IsNotNull(result);
var model = result.Model as CarPartsViewModel;
Assert.IsNotNull(model);
Assert.IsInstanceOf <CarPartsViewModel>(model);
}
public void Delete_GivenValidCarId_ShouldCallDelete()
{
//---------------Set up test pack-------------------
var car = new CarPartBuilder().Build();
var id = car.CarPartId;
var carRepository = Substitute.For <ICarPartRepository>();
carRepository.GetCarPartBy(id).Returns(car);
var carController = CreateBuilder()
.WithCarPartRepository(carRepository)
.Build();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = carController.Delete(id);
//---------------Test Result -----------------------
carRepository.Received().Delete(car);
}
public void Edit_Get_GivenValidCarId_ShouldCallGetCarByIdFromRepo()
{
//---------------Set up test pack-------------------
var car = new CarBuilder().WithNewId().Build();
var part = new PartBuilder().WithNewId().Build();
var carPart = new CarPartBuilder().WithNewId().WithCar(car).WithPart(part).Build();
var id = carPart.CarPartId;
var carPartRepository = Substitute.For <ICarPartRepository>();
var partRepository = Substitute.For <IPartRepository>();
var carRepository = Substitute.For <ICarRepository>();
var mapper = ResolveMapper();
carPartRepository.GetCarPartBy(id).Returns(carPart);
var parts = new List <TestHabanero.BO.Part> {
part
};
var cars = new List <Car> {
car
};
partRepository.GetParts().Returns(parts);
carRepository.GetCars().Returns(cars);
var carController = CreateBuilder()
.WithCarPartRepository(carPartRepository)
.WithCarRepository(carRepository)
.WithPartRepository(partRepository)
.WithMappingEngine(mapper)
.Build();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = carController.Edit(id);
//---------------Test Result -----------------------
carPartRepository.Received().GetCarPartBy(id);
}
public void Delete_GivenValidCarId_ShouldRedirectToIndex()
{
//---------------Set up test pack-------------------
var car = new CarPartBuilder().Build();
var id = car.CarPartId;
var carRepository = Substitute.For <ICarPartRepository>();
carRepository.GetCarPartBy(id).Returns(car);
var carController = CreateBuilder()
.WithCarPartRepository(carRepository)
.Build();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = carController.Delete(id) as RedirectToRouteResult;
//---------------Test Result -----------------------
Assert.IsNotNull(result);
var actionName = result.RouteValues["action"];
Assert.AreEqual("Index", actionName);
}
public void Index_ShouldCallMappingEngine()
{
//---------------Set up test pack-------------------
var part = new CarPartBuilder().WithNewId().Build();
var parts = new List <CarPart> {
part
};
var partRepository = Substitute.For <ICarPartRepository>();
partRepository.GetCarPart().Returns(parts);
var mappingEngine = Substitute.For <IMappingEngine>();
var partController = CreateBuilder()
.WithCarPartRepository(partRepository)
.WithMappingEngine(mappingEngine)
.Build();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var results = partController.Index() as ViewResult;
//---------------Test Result -----------------------
mappingEngine.Received().Map <List <CarPart>, List <CarPartsIndexViewModel> >(parts);
}
