public void TestInsertExistingCar()
        {
            using (var vehiclesContext = new VehiclesContext(_fixture.options))
            {
                Car carToInsert = new Car
                {
                    CarId         = 2,
                    MakeId        = 1,
                    Engine        = "v4",
                    Doors         = 4,
                    Wheels        = 4,
                    BodyTypeId    = 2,
                    ModelId       = 3,
                    AddDate       = DateTime.Today,
                    IsSold        = false,
                    VehicleTypeId = 1
                };

                CarRepository carRepository = new CarRepository(vehiclesContext);
                int           carId         = carRepository.InsertCar(carToInsert);

                Assert.Equal(0, carId);
                Car latest_car = new VehiclesContext(_fixture.options).Cars.OrderByDescending(c => c.CarId).First();

                Assert.NotEqual(carToInsert.CarId, latest_car.CarId);
            }
        }
        public void TestGetMakesFilledDatabase()
        {
            SelectListItem nissanItem = new SelectListItem
            {
                Value = "1",
                Text  = "Nissan"
            };
            SelectListItem jeepItem = new SelectListItem
            {
                Value = "2",
                Text  = "Jeep"
            };
            List <SelectListItem> validMakesList = new List <SelectListItem>()
            {
                jeepItem,
                nissanItem
            };

            using (var vehiclesContext = new VehiclesContext(_fixture.options))
            {
                CarRepository         carRepository = new CarRepository(vehiclesContext);
                List <SelectListItem> makes         = carRepository.GetAllMakesSelectList().ToList();
                Assert.Equal(2, makes.Count());
                int indexItem = 0;
                foreach (SelectListItem item in validMakesList)
                {
                    Assert.Equal(validMakesList[indexItem].Value, makes[indexItem].Value);
                    Assert.Equal(validMakesList[indexItem].Text, makes[indexItem].Text);
                    indexItem++;
                }
            }
        }
        public void TestGetModelsMakeIdValid()
        {
            SelectListItem xTrailItem = new SelectListItem {
                Value = "1",
                Text  = "X-Trail"
            };
            SelectListItem pathfinderItem = new SelectListItem
            {
                Value = "2",
                Text  = "Pathfinder"
            };
            List <SelectListItem> validModelsList = new List <SelectListItem>()
            {
                pathfinderItem,
                xTrailItem
            };

            using (var vehiclesContext = new VehiclesContext(_fixture.options))
            {
                CarRepository         carRepository = new CarRepository(vehiclesContext);
                List <SelectListItem> models        = carRepository.GetModelsSelectListItemsFromMakeId(1).ToList();
                Assert.Equal(2, models.Count());
                int indexItem = 0;
                foreach (SelectListItem item in validModelsList)
                {
                    Assert.Equal(validModelsList[indexItem].Value, models[indexItem].Value);
                    Assert.Equal(validModelsList[indexItem].Text, models[indexItem].Text);
                    indexItem++;
                }
            }
        }
        static void Main(string[] args)
        {
            VehiclesContext context = new VehiclesContext();

            context.Database.Initialize(true);
            context.SaveChanges();
        }
        public ModelsFixture()
        {
            options = new DbContextOptionsBuilder <VehiclesContext>()
                      .UseInMemoryDatabase(databaseName: "ModelsDataBase")
                      .Options;

            using var vehicleContext = new VehiclesContext(options);
            vehicleContext.Models.Add(new Model
            {
                ModelId = 1,
                MakeId  = 1,
                Name    = "X-Trail"
            });

            vehicleContext.Models.Add(new Model
            {
                ModelId = 2,
                MakeId  = 1,
                Name    = "Pathfinder"
            });

            vehicleContext.Models.Add(new Model
            {
                ModelId = 3,
                MakeId  = 2,
                Name    = "Cherokee"
            });
            vehicleContext.SaveChanges();
        }
        public void TestGetAllBodyTypesFilledDatabase()
        {
            SelectListItem wagonItem = new SelectListItem
            {
                Value = "1",
                Text  = "Wagon"
            };
            SelectListItem suvItem = new SelectListItem
            {
                Value = "2",
                Text  = "SUV"
            };
            List <SelectListItem> validBodyTypesList = new List <SelectListItem>()
            {
                suvItem,
                wagonItem
            };

            using (var vehiclesContext = new VehiclesContext(_fixture.options))
            {
                CarRepository         carRepository = new CarRepository(vehiclesContext);
                List <SelectListItem> bodyTypes     = carRepository.GetAllBodyTypesSelectList().ToList();
                Assert.Equal(2, bodyTypes.Count());
                int indexItem = 0;
                foreach (SelectListItem item in validBodyTypesList)
                {
                    Assert.Equal(validBodyTypesList[indexItem].Value, bodyTypes[indexItem].Value);
                    Assert.Equal(validBodyTypesList[indexItem].Text, bodyTypes[indexItem].Text);
                    indexItem++;
                }
            }
        }
 public void TestGetCarByIdValidId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         Car           car           = carRepository.GetCarById(1);
         Car           validCar      = new Car
         {
             CarId         = 1,
             MakeId        = 1,
             Engine        = "v6",
             Doors         = 4,
             Wheels        = 4,
             BodyTypeId    = 1,
             ModelId       = 1,
             AddDate       = DateTime.Today,
             IsSold        = false,
             VehicleTypeId = 1
         };
         Assert.Equal(validCar.CarId, car.CarId);
         Assert.Equal(validCar.MakeId, car.MakeId);
         Assert.Equal(validCar.Engine, car.Engine);
         Assert.Equal(validCar.Doors, car.Doors);
         Assert.Equal(validCar.Wheels, car.Wheels);
         Assert.Equal(validCar.BodyTypeId, car.BodyTypeId);
         Assert.Equal(validCar.ModelId, car.ModelId);
         Assert.Equal(validCar.AddDate, car.AddDate);
         Assert.Equal(validCar.IsSold, car.IsSold);
         Assert.Equal(validCar.VehicleTypeId, car.VehicleTypeId);
     }
 }
 public void TestGetModelHighId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         Model         model         = carRepository.GetModelById(10);
         Assert.Null(model);
     }
 }
 public void TestGetModelsHighMakeId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository         = new CarRepository(vehiclesContext);
         IEnumerable <SelectListItem> models = carRepository.GetModelsSelectListItemsFromMakeId(100);
         Assert.Equal(Enumerable.Empty <SelectListItem>(), models);
     }
 }
 public void TestGetMakeHighId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         Make          make          = carRepository.GetMakeById(10);
         Assert.Null(make);
     }
 }
 public void TestGetCarByIdHighId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         Car           car           = carRepository.GetCarById(100);
         Assert.Null(car);
     }
 }
 public void TestGetVehicleTypeByNameSpecialString()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         VehicleType   vehicleType   = carRepository.GetVehicleTypeByName("#%@****\"");
         Assert.Null(vehicleType);
     }
 }
 public void TestGetBodyTypeByIdHighId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         BodyType      bodyType      = carRepository.GetBodyTypeById(10);
         Assert.Null(bodyType);
     }
 }
 public void TestGetVehicleTypeByNameRandomString()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         VehicleType   vehicleType   = carRepository.GetVehicleTypeByName("asdfaf");
         Assert.Null(vehicleType);
     }
 }
 public void TestGetVehicleTypeByIdNegative()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         VehicleType   vehicleType   = carRepository.GetVehicleTypeById(-1);
         Assert.Null(vehicleType);
     }
 }
 public void TestGetAllBodyTypesEmptyDatabase()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         vehiclesContext.Database.EnsureDeleted();
         vehiclesContext.Database.EnsureCreated();
         CarRepository carRepository            = new CarRepository(vehiclesContext);
         IEnumerable <SelectListItem> bodyTypes = carRepository.GetAllBodyTypesSelectList();
         Assert.Equal(Enumerable.Empty <SelectListItem>(), bodyTypes);
     }
 }
 public void VehiclesContextHasFiveEntitiesInModel()
 {
     using (var context = new VehiclesContext())
     {
         var oc = (context as IObjectContextAdapter).ObjectContext;
         foreach (var entity in oc.MetadataWorkspace.GetItems<EntityType>(DataSpace.CSpace).ToList())
         {
             Debug.WriteLine(entity.FullName);
         }
         Assert.IsTrue(oc.MetadataWorkspace.GetItems<EntityType>(DataSpace.CSpace).Count == 5);
     }
 }
 public void TestGetBodyTypeByIdValidId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         BodyType      bodyType      = carRepository.GetBodyTypeById(1);
         BodyType      validBodyType = new BodyType {
             BodyTypeId = 1, Name = "Wagon"
         };
         Assert.Equal(validBodyType.BodyTypeId, bodyType.BodyTypeId);
         Assert.Equal(validBodyType.Name, bodyType.Name);
     }
 }
        private async Task CreatePurchasedVehicleListAsync()
        {
            using (var context = new VehiclesContext())
            {
                List <PurchasedVehicle> purchased = await context.Vehicles.ToListAsync();

                foreach (var v in purchased)
                {
                    Console.WriteLine($"{v.VIN}{v.Year}{v.Make}{v.Model}{v.Color}{v.Miles}{v.Cost}");
                }
            }
            Console.WriteLine();
        }
 public void TestGetMakeValidId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         Make          make          = carRepository.GetMakeById(1);
         Make          validMake     = new Make {
             MakeId = 1, Name = "Nissan"
         };
         Assert.Equal(validMake.MakeId, make.MakeId);
         Assert.Equal(validMake.Name, make.Name);
     }
 }
 public void TestGetVehicleTypeByNameValidString()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository    = new CarRepository(vehiclesContext);
         VehicleType   vehicleType      = carRepository.GetVehicleTypeByName("Car");
         VehicleType   validVehicleType = new VehicleType {
             VehicleTypeId = 1, Name = "Car"
         };
         Assert.Equal(validVehicleType.VehicleTypeId, vehicleType.VehicleTypeId);
         Assert.Equal(validVehicleType.Name, vehicleType.Name);
     }
 }
 public void TestGetModelValidId()
 {
     using (var vehiclesContext = new VehiclesContext(_fixture.options))
     {
         CarRepository carRepository = new CarRepository(vehiclesContext);
         Model         model         = carRepository.GetModelById(1);
         Model         validModel    = new Model {
             ModelId = 1, MakeId = 1, Name = "X-Trail"
         };
         Assert.Equal(validModel.ModelId, model.ModelId);
         Assert.Equal(validModel.MakeId, model.MakeId);
         Assert.Equal(validModel.Name, model.Name);
     }
 }
        public FilteringUIViewModel()
        {
            if (this.IsInDesignMode())
            {
                return;
            }
            var context = new VehiclesContext();

            Vehicles          = context.Models.ToList();
            Trademarks        = context.Trademarks.ToList();
            TransmissionTypes = context.TransmissionTypes.ToList();
            BodyStyles        = context.BodyStyles.ToList();
            DoorTypes         = new int[] { 2, 3, 4 };
            CalculateProperties();
        }
        public static void InitializeDbForTests(VehiclesContext db)
        {
            var car1Id = Guid.Parse("e7341f86-28bd-49bc-9509-e23752cfa450");
            var car2Id = Guid.Parse("b27f84a0-6ddb-44e6-8f31-123eca58ecbe");
            var car3Id = Guid.Parse("fdaac995-ea18-41ff-8f16-a200d6ec7a40");

            var cars = new List <Car>()
            {
                new Car
                {
                    Id             = car1Id,
                    Type           = VehicleType.Car,
                    Make           = "Toyota",
                    Model          = "Yaris",
                    NumberOfWheels = 4,
                    NumberOfDoors  = 5,
                    Engine         = "V4",
                    BodyType       = CarBodyType.Sedan
                },
                new Car
                {
                    Id             = car2Id,
                    Type           = VehicleType.Car,
                    Make           = "Toyota",
                    Model          = "RAV4",
                    NumberOfWheels = 4,
                    NumberOfDoors  = 5,
                    Engine         = "V6",
                    BodyType       = CarBodyType.Hatchback
                },
                new Car
                {
                    Id             = car3Id,
                    Type           = VehicleType.Truck,
                    Make           = "Ford",
                    Model          = "Ranger",
                    NumberOfWheels = 4,
                    NumberOfDoors  = 4,
                    Engine         = "V8",
                    BodyType       = CarBodyType.Sedan
                }
            };

            db.Cars.AddRange(cars);
            db.SaveChanges();
        }
        public CarsFixture()
        {
            options = new DbContextOptionsBuilder <VehiclesContext>()
                      .UseInMemoryDatabase(databaseName: "CarsDataBase")
                      .Options;

            using var vehicleContext = new VehiclesContext(options);
            for (int i = 0; i < 12; i += 2)
            {
                vehicleContext.Cars.Add(new Car
                {
                    CarId         = i + 1,
                    MakeId        = 1,
                    Engine        = "v6",
                    Doors         = 4,
                    Wheels        = 4,
                    BodyTypeId    = 1,
                    ModelId       = 1,
                    AddDate       = DateTime.Today,
                    IsSold        = false,
                    VehicleTypeId = 1
                });

                vehicleContext.Cars.Add(new Car
                {
                    CarId         = i + 2,
                    MakeId        = 1,
                    Engine        = "v4",
                    Doors         = 4,
                    Wheels        = 4,
                    BodyTypeId    = 2,
                    ModelId       = 3,
                    AddDate       = DateTime.Today,
                    IsSold        = false,
                    VehicleTypeId = 1
                });
            }


            vehicleContext.SaveChanges();
        }
        public BodyTypesFixture()
        {
            options = new DbContextOptionsBuilder <VehiclesContext>()
                      .UseInMemoryDatabase(databaseName: "BodyTypesDataBase")
                      .Options;

            using var vehicleContext = new VehiclesContext(options);
            vehicleContext.BodyTypes.Add(new BodyType
            {
                BodyTypeId = 1,
                Name       = "Wagon"
            });

            vehicleContext.BodyTypes.Add(new BodyType
            {
                BodyTypeId = 2,
                Name       = "SUV"
            });

            vehicleContext.SaveChanges();
        }
        public MakesFixture()
        {
            options = new DbContextOptionsBuilder <VehiclesContext>()
                      .UseInMemoryDatabase(databaseName: "MakesDataBase")
                      .Options;

            using var vehicleContext = new VehiclesContext(options);
            vehicleContext.Makes.Add(new Make
            {
                MakeId = 1,
                Name   = "Nissan"
            });

            vehicleContext.Makes.Add(new Make
            {
                MakeId = 2,
                Name   = "Jeep"
            });

            vehicleContext.SaveChanges();
        }
        public VehicleTypesFixture()
        {
            options = new DbContextOptionsBuilder <VehiclesContext>()
                      .UseInMemoryDatabase(databaseName: "VehicleTypesDataBase")
                      .Options;

            using var vehicleContext = new VehiclesContext(options);
            vehicleContext.VehicleTypes.Add(new VehicleType
            {
                VehicleTypeId = 1,
                Name          = "Car"
            });

            vehicleContext.VehicleTypes.Add(new VehicleType
            {
                VehicleTypeId = 2,
                Name          = "Boat"
            });

            vehicleContext.SaveChanges();
        }
        public void TestInsertValidCar()
        {
            using (var vehiclesContext = new VehiclesContext(_fixture.options))
            {
                Car carToInsert = new Car
                {
                    CarId         = 13,
                    MakeId        = 1,
                    Engine        = "v6",
                    Doors         = 4,
                    Wheels        = 4,
                    BodyTypeId    = 1,
                    ModelId       = 1,
                    AddDate       = DateTime.Today,
                    IsSold        = false,
                    VehicleTypeId = 1
                };

                CarRepository carRepository = new CarRepository(vehiclesContext);
                int           carId         = carRepository.InsertCar(carToInsert);

                Assert.Equal(13, carId);
                Car latest_car = new VehiclesContext(_fixture.options).Cars.OrderByDescending(c => c.CarId).First();

                Assert.Equal(carToInsert.CarId, latest_car.CarId);
                Assert.Equal(carToInsert.MakeId, latest_car.MakeId);
                Assert.Equal(carToInsert.Engine, latest_car.Engine);
                Assert.Equal(carToInsert.Doors, latest_car.Doors);
                Assert.Equal(carToInsert.Wheels, latest_car.Wheels);
                Assert.Equal(carToInsert.BodyTypeId, latest_car.BodyTypeId);
                Assert.Equal(carToInsert.ModelId, latest_car.ModelId);
                Assert.Equal(carToInsert.AddDate, latest_car.AddDate);
                Assert.Equal(carToInsert.IsSold, latest_car.IsSold);
                Assert.Equal(carToInsert.VehicleTypeId, latest_car.VehicleTypeId);
            }
        }
 public CarMakesController(VehiclesContext context)
 {
     _context = context;
 }
Exemple #31
0
 public HomeController(IVehiclesService vehicleService, VehiclesContext modelContext, ILogger <HomeController> logger)
 {
     _vehicleService = vehicleService;
     _modelContext   = modelContext;
     _logger         = logger;
 }
 public VehicleTypeRepository(VehiclesContext dbContext)
 {
     this.dbContext = dbContext;
     this.dbContext.Configuration.ProxyCreationEnabled = false;
 }