public async void UpdateCarInRaceAsync_given_car_updates_car()
        {
            var builder = new DbContextOptionsBuilder <SlotCarContext>().UseInMemoryDatabase("UpdateCarInRace");

            SlotCarContext context = new SlotCarContext(builder.Options);

            context.Database.EnsureCreated();

            using (var repository = new RaceRepository(context))
            {
                var track = new Track
                {
                    Name           = "Monte Carlo",
                    LengthInMeters = 1002,
                    MaxCars        = 20
                };

                var race = new Race
                {
                    Id           = 42,
                    NumberOfLaps = 5,
                    Track        = track
                };

                var car = new Car
                {
                    Id     = 42,
                    Name   = "Lynet McQueen",
                    Driver = "McQueen"
                };

                var carinrace = new CarInRace
                {
                    Car  = car,
                    Race = race
                };
                await context.Races.AddAsync(race);

                await context.Tracks.AddAsync(track);

                await context.Cars.AddAsync(car);

                await context.CarsInRace.AddAsync(carinrace);

                await context.SaveChangesAsync();

                var dto = new RaceCarDTO
                {
                    CarId         = 42,
                    RaceId        = 42,
                    StartPosition = 1
                };

                var result = await repository.UpdateCarInRaceAsync(dto);

                Assert.True(result.ok);
            }
        }
        public async Task TestUpdateCarInRaceAsync()
        {
            using (raceRepository)
            {
                Car car = new Car()
                {
                    Driver = "Mads", Name = "Suzuki"
                };

                var track = new Track()
                {
                    BestTime       = 121213123,
                    LengthInMeters = 123214,
                    MaxCars        = 50,
                    Name           = "RaceTrack"
                };
                var race = new Race()
                {
                    NumberOfLaps = 5,
                    PlannedEnd   = new DateTime(1920, 11, 11),
                    PlannedStart = new DateTime(1920, 11, 11),
                    Track        = track
                };
                var carInRace = new CarInRace()
                {
                    Car = car, Race = race
                };
                await context.AddAsync(carInRace);

                await context.SaveChangesAsync();

                var UpdatedCarInRaceInfo = new RaceCarDTO()
                {
                    CarId         = car.Id,
                    RaceId        = race.Id,
                    EndPosition   = 2,
                    FastestLap    = 123123,
                    StartPosition = 1212,
                    TotalTime     = 2121212
                };
                await raceRepository.UpdateCarInRaceAsync(UpdatedCarInRaceInfo);

                Assert.Equal(UpdatedCarInRaceInfo.EndPosition, context.CarsInRace.Find(carInRace.RaceId, carInRace.CarId).EndPosition);
                Assert.Equal(UpdatedCarInRaceInfo.FastestLap, context.CarsInRace.Find(carInRace.RaceId, carInRace.CarId).FastestLap);
                Assert.Equal(UpdatedCarInRaceInfo.TotalTime, context.CarsInRace.Find(carInRace.RaceId, carInRace.CarId).TotalTime);
                Assert.Equal(UpdatedCarInRaceInfo.StartPosition, context.CarsInRace.Find(carInRace.RaceId, carInRace.CarId).StartPosition);
            }
        }
Exemple #3
0
        public (bool ok, string error) UpdateCarInRace(RaceCarDTO car)
        {
            CarInRace toBeUpdated = (from races in context.CarsInRace
                                     where races.CarId == car.CarId && races.RaceId == car.RaceId
                                     select races).FirstOrDefault();

            if (toBeUpdated != null)
            {
                toBeUpdated.FastestLap    = car.FastestLap;
                toBeUpdated.EndPosition   = car.EndPosition;
                toBeUpdated.CarId         = car.CarId;
                toBeUpdated.RaceId        = car.RaceId;
                toBeUpdated.StartPosition = car.StartPosition;
                toBeUpdated.TotalTime     = car.TotalTime;
                context.SaveChanges();
                return(true, "");
            }
            return(false, "no Car In Race found");
        }
Exemple #4
0
        public (bool ok, string error) UpdateCarInRace(RaceCarDTO car)
        {
            var carInRace = _context.CarsInRace.Find(car.CarId, car.RaceId);

            if (carInRace == null)
            {
                return(false, "Car not found");
            }

            carInRace.CarId         = car.CarId;
            carInRace.RaceId        = car.RaceId;
            carInRace.StartPosition = car.StartPosition;
            carInRace.EndPosition   = car.EndPosition;
            carInRace.FastestLap    = car.FastestLap;
            carInRace.TotalTime     = car.TotalTime;

            _context.SaveChanges();

            return(true, "Car has been updated");
        }
Exemple #5
0
        public void UpdateCarInRace_given_RaceCarDTO_updates_car()
        {
            var connection = new SqliteConnection("DataSource=:memory:");

            connection.Open();

            var builder = new DbContextOptionsBuilder <SlotCarContext>()
                          .UseSqlite(connection);

            _context = new SlotCarContext(builder.Options);
            _context.Database.EnsureCreated();

            var track = new Track()
            {
                Id             = 10,
                Name           = "Awesome Track",
                LengthInMeters = 2000,
                MaxCars        = 12
            };

            var race = new Race()
            {
                Id           = 5,
                TrackId      = 10,
                Track        = track,
                NumberOfLaps = 3
            };

            var car = new Car()
            {
                Id = 20, Name = "Awesome Car", Driver = "Awesome Driver"
            };
            var car2 = new Car()
            {
                Id = 21, Name = "More Awesome Car", Driver = "Awesomest Driver"
            };

            var carInRace = new CarInRace()
            {
                CarId  = car.Id,
                RaceId = race.Id,
                Car    = car,
                Race   = race,
            };

            _context.Tracks.Add(track);
            _context.Races.Add(race);
            _context.Cars.Add(car);
            _context.Cars.Add(car2);
            _context.CarsInRace.Add(carInRace);
            _context.SaveChanges();

            car.Driver = "Awesomest Driver";

            var newCarInRace = new RaceCarDTO()
            {
                CarId  = car.Id,
                RaceId = race.Id,
            };

            using (var repository = new RaceRepository(_context))
            {
                var DBCarInRace = _context.CarsInRace.FirstOrDefault();
                var DBCar       = _context.Cars.Find(DBCarInRace.CarId);
                Assert.Equal(car.Name, DBCar.Name);
                Assert.Equal(car.Driver, DBCar.Driver);
            }
        }