public void MakeServiceReadTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var vMake = new VehicleMakeDomain()
{
Name = "MakeServiceReadTest", Abrv = "MakeServiceReadTest", VehicleModel = null
};
var testService = new MakeService(makeRepository, modelRepository);
IEnumerable <IVehicleMakeDomain> readAll = null;
IVehicleMakeDomain targetItem = null;
Task.Run(async() =>
{
readAll = await testService.ReadAll();
Assert.IsNotNull(readAll);
targetItem = readAll.LastOrDefault();
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testService.Read(targetItem.VehicleMakeId);
//Assert
Assert.AreEqual(targetItem.VehicleMakeId, result.VehicleMakeId);
}).GetAwaiter().GetResult();
}
public void MakeRepositoryGetAllTest()
{
//Arrange
IncludeAllMappings.include();
var vMake = new VehicleMakeDomain()
{
Name = "MakeRepositoryGetAllTest", Abrv = "MakeRepositoryGetAllTest", VehicleMakeId = Guid.NewGuid(), VehicleModel = null
};
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new MakeRepository(repository);
int response;
Task.Run(async() =>
{
response = await testRepository.Add(vMake);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Act
Task.Run(async() =>
{
var result = await testRepository.GetAll();
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public void MakeControllerGetAllTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var makeService = new MakeService(makeRepository, modelRepository);
var testController = new MakeController(makeService);
testController.Request = new HttpRequestMessage();
testController.Configuration = new HttpConfiguration();
//Add make
var vMake = new VehicleMakeView()
{
Name = "MakeControllerGetAllTest", Abrv = "MakeControllerGetAllTest"
};
Task.Run(async() =>
{
var response = await testController.Add(vMake);
Assert.IsNotNull(response);
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testController.GetAll();
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public void CanRemoveMake()
{
var repo = new MakeRepository();
Assert.AreEqual(3, repo.GetAll().Count);
repo.Remove(1);
Assert.AreEqual(2, repo.GetAll().Count);
}
public UnitOfWork(ApplicationDBContext context)
{
_context = context;
Makes = new MakeRepository(_context);
Models = new ModelRepository(_context);
Vehicles = new VehicleRepository(_context);
Clients = new ClientRepository(_context);
}
public void CanAddMake()
{
var repo = new MakeRepository();
Assert.AreEqual(3, repo.GetAll().Count);
repo.Add(new Make()
{
MakeName = "Big"
});
Assert.AreEqual(4, repo.GetAll().Count);
}
public void ModelServiceReadAllTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var makeService = new MakeService(makeRepository, modelRepository);
var testService = new ModelService(modelRepository);
//Add make
var vMake = new VehicleMakeDomain()
{
Name = "ModelServiceReadAllTest", Abrv = "ModelServiceReadAllTest", VehicleModel = null
};
Task.Run(async() =>
{
var response = await makeService.Add(vMake);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
IVehicleMakeDomain targetMake = null;
//Get make
Task.Run(async() =>
{
var response = await makeService.ReadAll();
Assert.IsNotNull(response);
targetMake = response.LastOrDefault();
}).GetAwaiter().GetResult();
//Create model
var vModel = new VehicleModelDomain()
{
Name = "ModelServiceReadAllTest", Abrv = "ModelServiceReadAllTest", VehicleMakeId = targetMake.VehicleMakeId
};
//Add model
Task.Run(async() =>
{
var response = await testService.Add(vModel);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testService.ReadAll();
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public async Task <IEnumerable <IVehicleMakeDomain> > ReadAll()
{
try
{
var response = await MakeRepository.GetAll();
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IVehicleMakeDomain> Read(Guid id)
{
//Get maker
var response = await MakeRepository.Get(id);
//Get his models
var models = await ModelRepository.GetMakersModels(response.VehicleMakeId);
//Inject them
response.VehicleModel = models;
return(response);
}
public void MakeControllerUpdateTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var makeService = new MakeService(makeRepository, modelRepository);
var testController = new MakeController(makeService);
testController.Request = new HttpRequestMessage();
testController.Configuration = new HttpConfiguration();
//Add make
var vMake = new VehicleMakeView()
{
Name = "MakeControllerUpdateTest", Abrv = "MakeControllerUpdateTest"
};
Task.Run(async() =>
{
var response = await testController.Add(vMake);
Assert.IsNotNull(response);
}).GetAwaiter().GetResult();
//Get make
VehicleMakeView targetItem = null;
JavaScriptSerializer JSS = new JavaScriptSerializer();
Task.Run(async() =>
{
var response = await testController.GetAll();
Assert.IsNotNull(response);
IEnumerable <VehicleMakeView> obj = JSS.Deserialize <IEnumerable <VehicleMakeView> >(response.Content.ReadAsStringAsync().Result);
targetItem = obj.LastOrDefault();
}).GetAwaiter().GetResult();
targetItem.Name = "MakeControllerUpdateTestTested";
Task.Run(async() =>
{
//Act
var response = await testController.Update(targetItem);
//Assert
int obj = JSS.Deserialize <int>(response.Content.ReadAsStringAsync().Result);
Assert.AreEqual(1, obj);
}).GetAwaiter().GetResult();
}
public void CanAddMake()
{
Make make = new Make()
{
MakeName = "Ford",
DateAdded = new DateTime(2014, 06, 09),
UserId = allUsers[0].Id
};
var repo = new MakeRepository();
repo.AddMake(make);
// Now check in the DB if the record was added
}
public void MakeServiceReadAllTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var testService = new MakeService(makeRepository, modelRepository);
Task.Run(async() =>
{
//Act
var result = await testService.ReadAll();
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public void MakeServiceAddTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var vMake = new VehicleMakeDomain()
{
Name = "MakeRepositoryAddTest", Abrv = "MakeRepositoryAddTest", VehicleModel = null
};
var testService = new MakeService(makeRepository, modelRepository);
Task.Run(async() =>
{
//Act
var result = await testService.Add(vMake);
//Assert
Assert.AreEqual(1, result);
}).GetAwaiter().GetResult();
}
public void MakeRepositoryGetTest()
{
//Arrange
IncludeAllMappings.include();
var vMake = new VehicleMakeDomain()
{
Name = "MakeRepositoryGetTest", Abrv = "MakeRepositoryGetTest", VehicleModel = null
};
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new MakeRepository(repository);
int response;
Task.Run(async() =>
{
response = await testRepository.Add(vMake);
//Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
IEnumerable <IVehicleMakeDomain> getAll;
IVehicleMakeDomain targetMake = null;
Task.Run(async() =>
{
getAll = await testRepository.GetAll();
//Assert
Assert.IsNotNull(getAll);
foreach (var item in getAll)
{
targetMake = item;
}
var result = await testRepository.Get(targetMake.VehicleMakeId);
//Assert
Assert.AreEqual(targetMake.VehicleMakeId, result.VehicleMakeId);
}).GetAwaiter().GetResult();
}
public async Task <int> Delete(IVehicleMakeDomain entry)
{
return(await MakeRepository.Delete(AutoMapper.Mapper.Map <VehicleMakeDomain>(entry)));
}
public MakeLogic()
{
_makeRepository = new MakeRepository();
}
public async Task <int> Update(IVehicleMakeDomain entry)
{
return(await MakeRepository.Update(entry));
}
public void CanGetMake()
{
var repo = new MakeRepository();
Assert.AreEqual("Jeep", repo.Get(1).MakeName);
}
public void CanGetAllMake()
{
var repo = new MakeRepository();
Assert.AreEqual(3, repo.GetAll().Count);
}
public void ModelRepositoryGetTest()
{
//Arrange
//Init repo
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new ModelRepository(repository);
var makeRepository = new MakeRepository(repository);
//Create maker
var vMake = new VehicleMakeDomain()
{
Name = "ModelRepositoryGetTest", Abrv = "ModelRepositoryGetTest"
};
Task.Run(async() =>
{
var response = await makeRepository.Add(vMake);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Get maker
IEnumerable <IVehicleMakeDomain> getAllMakers = null;
IVehicleMakeDomain targetMaker = null;
Task.Run(async() =>
{
getAllMakers = await makeRepository.GetAll();
Assert.IsNotNull(getAllMakers);
foreach (var item in getAllMakers)
{
targetMaker = item;
}
}).GetAwaiter().GetResult();
//Create model
var vModel = new VehicleModelDomain()
{
Name = "ModelRepositoryGetTest", Abrv = "ModelRepositoryGetTest", VehicleMakeId = targetMaker.VehicleMakeId
};
//Add model
Task.Run(async() =>
{
var response = await testRepository.Add(vModel);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Get model
IEnumerable <IVehicleModelDomain> getAll;
IVehicleModelDomain targetModel = null;
Task.Run(async() =>
{
getAll = await testRepository.GetAll();
Assert.IsNotNull(getAll);
foreach (var item in getAll)
{
targetModel = item;
}
var result = await testRepository.Get(targetModel.VehicleModelId);
//Assert
Assert.AreEqual(targetModel.VehicleModelId, result.VehicleModelId);
}).GetAwaiter().GetResult();
}
public async Task <int> Delete(Guid id)
{
return(await MakeRepository.Delete(id));
}
public WarehouseService(MakeRepository makeRepository, ModelRepository modelRepository, CarRepository carRepository)
{
this.makeRepository = makeRepository;
this.modelRepository = modelRepository;
this.carRepository = carRepository;
}
public async Task <int> Add(IVehicleMakeDomain entry)
{
return(await MakeRepository.Add(entry));
}
