public void test_repository_full_case()
{
var cars = new List<Car>
{
new Car { CarId = 1, Description = "Mustang" },
new Car { CarId = 2, Description = "Corvette" }
};
var carRepository = new CarRepository();
carRepository.Add(cars[0]);
carRepository.Add(cars[1]);
var returnedCars = carRepository.GetAll();
Assert.That(returnedCars.Count(), Is.EqualTo(2));
var car1 = carRepository.Get(1);
Assert.That(car1.Description, Is.EqualTo("Mustang"));
var car2 = carRepository.Get(2);
Assert.That(car2.Description, Is.EqualTo("Corvette"));
carRepository.Remove(1);
carRepository.Remove(2);
returnedCars = carRepository.GetAll();
Assert.That(returnedCars.Count(), Is.EqualTo(0));
}
public void test_repository_full_case()
{
var cars = new List <Car>
{
new Car {
CarId = 1, Description = "Mustang"
},
new Car {
CarId = 2, Description = "Corvette"
}
};
var carRepository = new CarRepository();
carRepository.Add(cars[0]);
carRepository.Add(cars[1]);
var returnedCars = carRepository.GetAll();
Assert.That(returnedCars.Count(), Is.EqualTo(2));
var car1 = carRepository.Get(1);
Assert.That(car1.Description, Is.EqualTo("Mustang"));
var car2 = carRepository.Get(2);
Assert.That(car2.Description, Is.EqualTo("Corvette"));
carRepository.Remove(1);
carRepository.Remove(2);
returnedCars = carRepository.GetAll();
Assert.That(returnedCars.Count(), Is.EqualTo(0));
}
public string CreateCar(string type, string model, int horsePower)
{
ICar car;
ICar carFromRepository = carsRepository.GetAll().FirstOrDefault(x => x.Model == model);
if (type == "Muscle")
{
if (carFromRepository != null)
{
throw new ArgumentException(String.Format(ExceptionMessages.CarExists, model));
}
car = new MuscleCar(model, horsePower);
carsRepository.Add(car);
}
else if (type == "Sports")
{
if (carFromRepository != null)
{
throw new ArgumentException(String.Format(ExceptionMessages.CarExists, model));
}
car = new SportsCar(model, horsePower);
carsRepository.Add(car);
}
return(String.Format(OutputMessages.CarCreated, type, model));
}
public async Task <int> AddAsync(CachedCar car)
{
Car c = new Car
{
Id = car.Id,
Colour = car.Colour,
CountryManufactured = car.CountryManufactured,
Make = car.Make,
Model = car.Model,
Price = car.Price,
Year = car.Year
};
int repo_id = await mainStoring.Add(c);
car.Id = repo_id;
CachedCar Cc = mainCachedStoring.AddOrUpdate(repo_id, car, (key, existingCar) =>
{
existingCar.Make = car.Make;
existingCar.Model = car.Model;
existingCar.Year = car.Year;
existingCar.CountryManufactured = car.CountryManufactured;
existingCar.Colour = car.Colour;
existingCar.Price = car.Price;
return(existingCar);
});
return(await Task.FromResult(repo_id));
}
public async Task AllEventsLogged()
{
var tire = Tire.Create(0, me);
var car = Car.Create("toyota", "camry", me);
car.AddTire(tire, me);
var options = new DbContextOptionsBuilder <CarMgmtContext>()
.UseInMemoryDatabase(databaseName: "all_events_logged_to_db")
.Options;
Car createdCar = null;
Tire createdTire = null;
using (var context = new CarMgmtContext(options))
{
var repo = new CarRepository(context);
createdCar = repo.Add(car);
createdTire = createdCar.Tires.Single();
await context.SaveChangesAsync();
}
using (var context = new CarMgmtContext(options))
{
var repo = new CarRepository(context);
createdCar = await repo.GetAsync(createdCar.Id);
var carCreatedEvent = context.CarEvents
.Single(e => e.EventName == nameof(CarCreated));
var tireCreatedEvent = context.TireEvents
.Single(e => e.TireId == createdTire.Id);
createdCar.SetMake("new make", me);
repo.Update(createdCar);
await context.SaveChangesAsync();
}
using (var context = new CarMgmtContext(options))
{
var repo = new CarRepository(context);
createdCar = await repo.GetAsync(createdCar.Id);
var carUpdatedEvent = context.CarEvents
.Single(e => e.EventName == nameof(MakeUpdated));
createdCar.SetTireMileage(createdTire.Id, 1000, me);
repo.Update(createdCar);
await context.SaveChangesAsync();
}
using (var context = new CarMgmtContext(options))
{
var tireUpdatedEvent = context.TireEvents
.Single(e => e.EventName == nameof(MileageUpdated));
}
}
public string CreateCar(string type, string model, int horsePower)
{
ICar car = null;
if (type == "Muscle")
{
car = new MuscleCar(model, horsePower);
}
if (type == "Sports")
{
car = new SportsCar(model, horsePower);
}
if (carRepository.GetByName(model) != null)
{
throw new ArgumentException(String.Format
(ExceptionMessages.CarExists, model));
}
if (car == null)
{
return(null);
}
carRepository.Add(car);
return(string.Format
(OutputMessages.CarCreated, car.GetType().Name, model));
}
public async Task <IActionResult> Post(Car value)
{
int NewValue = 0;
try
{
var CarList = new List <Car>();
CarList = await m_carRepository.GetAllCars();
CarList = CarList.Where(x => x.Id == value.Id).ToList();
if (CarList.Count > 0)
{
return(Ok("Same Id already exist"));
}
NewValue = await m_carRepository.Add(value);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok("Car Added"));
}
public void AddCar()
{
var repository = new CarRepository();
int id = repository.Add(carModel.Object);
Assert.AreEqual(id, 4);
}
public ActionResult Add(Car car)
{
if (ModelState.IsValid)
{
CarRepository.Add(car);
CarRepository.SaveChanges();
return(RedirectToAction("List"));
}
return(View(car));
}
public string CreateCar(string type, string model, int horsePower)
{
if (carRepository.GetByName(model) != null)
{
throw new ArgumentException(string.Format(ExceptionMessages.CarExists, model));
}
type += "Car";
if (type == typeof(MuscleCar).Name)
{
carRepository.Add(new MuscleCar(model, horsePower));
}
else if (type == typeof(SportsCar).Name)
{
carRepository.Add(new SportsCar(model, horsePower));
}
return(string.Format(OutputMessages.CarCreated, type, model));
}
public void AddCar(CarDTO cardto)
{
var car = new Car
{
Model = cardto.Model,
SeatCapacity = cardto.SeatCapacity
};
_repo.Add(car);
_repo.SaveChanges();
}
public string CreateCar(string type, string model, int horsePower)
{
ICar car = carFactory.CreateCar(type, horsePower, model);
if (carRepository.GetByName(model) != null)
{
//TODO: If wrong test, edit the EXCPETION MESSAGES CLASS!!!!
throw new ArgumentException(string.Format(ExceptionMessages.CarExists, car.Model));
}
carRepository.Add(car);
return(String.Format(OutputMessages.CarCreated, $"{type}Car", model));
}
public void CanUseCustomMocks()
{
CarRepository carRepository = new CarRepository();
carRepository.Add(new Car("Volvo"));
MyMockRepository mocks = new MyMockRepository();
IView view = (IView)mocks.QueryableMock(typeof(IView));
Presenter presenter = new Presenter(carRepository, view);
presenter.Render();
Car car = (Car)mocks.Query(view);
Assert.Equal("Volvo", car.Make);
}
public void EnterRepairShop(int id, int standNumber, string licensePlate, uint numberOfDays)
{
// we ensure that the stand is not occupied.
List <Car> allCars = repository.getAll();
Car verifyCar = allCars.Find(c => c.StandNumber == standNumber);
if (verifyCar != null && !verifyCar.LeftService)
{
throw new RuntimeException("That stand is already taken by another car!");
}
Car car = new Car(id, standNumber, licensePlate, numberOfDays);
repository.Add(car);
}
public void Add_ShouldWork()
{
// Arrange
var car = _cars[0];
var dbContextMock = new Mock <RentalContext>();
var dbSetMock = new Mock <DbSet <Car> >();
dbContextMock.Setup(t => t.Set <Car>()).Returns(dbSetMock.Object);
// Act
var carRepository = new CarRepository(dbContextMock.Object);
carRepository.Add(car);
// Assert
dbContextMock.Verify(t => t.Set <Car>(), Times.Once);
dbSetMock.Verify(t => t.Add(It.IsAny <Car>()), Times.Once);
}
public string AddCar(string type, string make, string model, string VIN, int horsePower)
{
ICar currentCar;
if (type == "SuperCar")
{
currentCar = new SuperCar(make, model, VIN, horsePower);
}
else if (type == "TunedCar")
{
currentCar = new TunedCar(make, model, VIN, horsePower);
}
else
{
throw new ArgumentException("Invalid car type!");
}
cars.Add(currentCar);
return($"Successfully added car {make} {model} ({VIN}).");
}
public string CreateCar(string type, string model, int horsePower)
{
ICar car = null;
if (type == "Muscle")
{
car = new MuscleCar(model, horsePower);
}
else if (type == "Sports")
{
car = new SportsCar(model, horsePower);
}
if (CarRepository.Colection.Any(el => el.Model == model))
{
throw new ArgumentException(string.Format(ExceptionMessages.CarExists, model));
}
CarRepository.Add(car);
return(string.Format(OutputMessages.CarCreated, car.GetType().Name, model));
}
public void CarRepository_Add_AddsCar()
{
var mockCarDbSet = UnitTestHelper.GetMockDbSet <Car>(GetTestCars());
var mockTechnicalPassportDbSet = UnitTestHelper.GetMockDbSet <TechnicalPassport>(GetTestTechnicalPassports());
var mockContext = GetMockContext(mockCarDbSet, mockTechnicalPassportDbSet);
var carRepo = new CarRepository(mockContext.Object);
var car = new Car
{
Brand = "Ferrari",
Model = "LaFerrari"
};
carRepo.Add(car);
mockCarDbSet.Verify(
m => m.Add(It.Is <Car>(
c => c.Brand == car.Brand &&
c.Model == car.Model)),
Times.Once);
}
private static void AddCar()
{
Console.WriteLine("");
Console.WriteLine("Specify Make: ");
var make = Console.ReadLine();
Console.WriteLine("Specify Model: ");
var model = Console.ReadLine();
Console.WriteLine("and now the Year: ");
var year = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("What colour is it?");
var colour = Console.ReadLine();
Console.WriteLine("Whats the odometer reading?");
var mile = Convert.ToInt32(Console.ReadLine());
carRepo.Add(make, model, year, colour, mile);
}
public APIResponse <Car> Add([FromBody] Car model)
{
APIResponse <Car> response = new APIResponse <Car> {
status = new APIResponseStatus()
{
IsSuccessful = false
}
};
try
{
response.item = _carRepository.Add(model);
response.status.IsSuccessful = true;
}
catch (Exception e)
{
response.status.ErrorMessage = e.Message;
}
return(response);
}
public string AddCar(string type, string make, string model, string VIN, int horsePower)
{
ICar car;
switch (type)
{
case "SuperCar":
car = new SuperCar(make, model, VIN, horsePower);
break;
case "TunedCar":
car = new TunedCar(make, model, VIN, horsePower);
break;
default:
throw new ArgumentException(ExceptionMessages.InvalidCarType);
}
cars.Add(car);
return(string.Format(OutputMessages.SuccessfullyAddedCar, make, model, VIN));
}
public string AddCar(string type, string make, string model, string VIN, int horsePower)
{
Car car = default;
if (type == "SuperCar")
{
car = new SuperCar(make, model, VIN, horsePower);
}
else if (type == "TunedCar")
{
car = new TunedCar(make, model, VIN, horsePower);
}
else
{
throw new ArgumentException(ExceptionMessages.InvalidCarType);
}
cars.Add(car);
return(string.Format(OutputMessages.SuccessfullyAddedCar, make, model, VIN));
}
public string CreateCar(string type, string model, int horsePower)
{
var car = this.carRep.GetByName(model);
if (car != null)
{
throw new ArgumentException($"Car {model} is already create.");
}
Car newCar = null;
if (type == "Muscle")
{
newCar = new MuscleCar(model, horsePower);
}
else if (type == "Sports")
{
newCar = new SportsCar(model, horsePower);
}
carRep.Add(newCar);
return($"{type}Car {model} is created.");
}
public string CreateCar(string type, string model, int horsePower)
{
if (cars.GetAll().Any(x => x.Model == model))
{
throw new ArgumentException($"Car {model} is already created.");
}
ICar car = null;
if (type == "Muscle")
{
car = new MuscleCar(model, horsePower);
}
else if (type == "Sports")
{
car = new SportsCar(model, horsePower);
}
cars.Add(car);
return($"{car.GetType().Name} {model} is created.");
}
public string CreateCar(string type, string model, int horsePower)
{
var carExist = this.carRepository.GetByName(model);
if (carExist != null)
{
throw new ArgumentException($"Car {model} is already created.");
}
ICar car = null;
if (type == "Muscle")
{
car = new MuscleCar(model, horsePower);
}
else if (type == "Sports")
{
car = new SportsCar(model, horsePower);
}
carRepository.Add(car);
return($"{car.GetType().Name} {model} is created.");
}
public ActionResult AddNewCar(CarViewModel carViewModel)
{
if (!ModelState.IsValid)
{
throw new HttpRequestException();
}
var brand = carBrandRepository.FindBrandByName(carViewModel.Brand);
var type = carTypeRepository.FindTypeByName(carViewModel.Type);
Car car = new Car
{
Name = carViewModel.Name,
TypeId = type.TypeId,
BrandId = brand.BrandID,
Price = carViewModel.Price
};
carRepository.Add(car);
carRepository.SaveChanges();
return(RedirectToAction("Index"));
}
public string CreateCar(string type, string model, int horsePower)
{
if (cars.GetAll().Any(x => x.Model == model))
{
string msg = string.Format(ExceptionMessages.CarExists, model);
throw new ArgumentException(msg);
}
ICar car = null;
if (type == "Muscle")
{
car = new MuscleCar(model, horsePower);
}
else if (type == "Sports")
{
car = new SportsCar(model, horsePower);
}
cars.Add(car);
string outputMsg = string.Format(OutputMessages.CarCreated, car.GetType().Name, model);
return(outputMsg);
}
public IHttpActionResult GetAddCars()
{
repo.Add();
return(Ok());
}
public async Task <ActionResult> Post(CarDTO car)
{
await carRepository.Add(car);
return(Ok("Car added"));
}
public void Add(Car item)
{
carRepo.Add(item);
}
public void AddCar(Car car)
{
_carRepository.Add(car);
_carRepository.Commit();
}