public void Create_New_Car_In_Create_Race_Repo()
{
var race = default(Race);
var dto = new RaceCreateDTO
{
Id = 1,
TrackId = 2,
NumberOfLaps = 7
};
var mock = new Mock <ISlotCarContext>();
mock.Setup(s => s.Races.Add(It.IsAny <Race>()))
.Callback <Race>(r => race = r);
using (var repository = new RaceRepository(mock.Object))
{
repository.Create(dto);
}
if (race != null)
{
Assert.Equal(1, race.Id);
Assert.Equal(2, race.TrackId);
Assert.Equal(7, race.NumberOfLaps);
}
else
{
Assert.True(true);
}
}
public async void CreateAsync_given_race_returns_raceid()
{
var race = default(Race);
var dto = new RaceCreateDTO
{
Id = 1,
TrackId = 2,
NumberOfLaps = 7
};
var mock = new Mock <ISlotCarContext>();
mock.Setup(s => s.Races.Add(It.IsAny <Race>())).Callback <Race>(r => race = r);
using (var repository = new RaceRepository(mock.Object))
{
await repository.CreateAsync(dto);
}
if (race != null)
{
Assert.Equal(2, race.TrackId);
Assert.Equal(7, race.NumberOfLaps);
}
else
{
Assert.True(true);
}
}
public static void Main()
{
var raceRepo = new RaceRepository();
var riderRepo = new RiderRepository();
var motorcycleRepo = new MotorcycleRepository();
var raceFactory = new RaceFactory();
var riderFactory = new RiderFactory();
var motorcycleFactory = new MotorcycleFactory();
var championshipController = new ChampionshipController(
raceRepo,
riderRepo,
motorcycleRepo,
raceFactory,
riderFactory,
motorcycleFactory);
var consoleReader = new ConsoleReader();
var consoleWriter = new ConsoleWriter();
var engine = new Engine(
championshipController,
consoleReader,
consoleWriter);
engine.Run();
}
protected override async Task OnParametersSetAsync()
{
_raceModelsList = await RaceRepository.GetRaces();
_raceTabs = GetRaceTabDictionary(_raceModelsList);
await ResetStats();
}
public static void Main(string[] args)
{
//TODO Add IEngine
//Motorcycle varche = new PowerMotorcycle("12214235", 75);
//Console.WriteLine(varche.HorsePower);
IMotorcycleFactory motorcycleFactory = new MotorcycleFactory();
IRaceFactory raceFactory = new RaceFactory();
IRiderFactory riderFactory = new RiderFactory();
MotorcycleRepository motorcycleRepository = new MotorcycleRepository();
RaceRepository raceRepository = new RaceRepository();
RiderRepository riderRepository = new RiderRepository();
IChampionshipController controller = new ChampionshipController(
motorcycleFactory,
raceFactory,
riderFactory,
motorcycleRepository,
raceRepository,
riderRepository);
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
IEngine engine = new Engine(reader, writer, controller);
engine.Run();
}
public ChampionshipController()
{
this.motorcycleRepository = new MotorcycleRepository();
this.riderRepository = new RiderRepository();
this.raceRepository = new RaceRepository();
this.riders = new List <IRider>();
}
public ChampionshipController()
{
this.carRepository = new CarRepository();
this.driverRepository = new DriverRepository();
this.raceRepository = new RaceRepository();
this.carFactory = new CarFactory();
}
public ReportManager()
{
_raceRepository = new RaceRepository();
_splitRepository = new SplitRepository();
_athleteRepository = new AthleteRepository();
Races = new ObservableCollection <Race>(_raceRepository.GetAll());
}
public bool submitReviewerResponse(ReviewerResponseDTO reviewerResponse, long userID, long RoleID)
{
ReviewerResponse request = new ReviewerResponse();
ObjectMapper.Map(reviewerResponse, request);
return(RaceRepository.submitReviewerResponse(request, userID, RoleID));
}
public static void Main(string[] args)
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
IRepository <IMotorcycle> motorcycleRepository = new MotorcycleRepository();
IRepository <IRace> raceRepository = new RaceRepository();
IRepository <IRider> riderRepository = new RiderRepository();
MotorcycleFactory motorcycleFactory = new MotorcycleFactory();
// Judge system does not require dependency inversion principle to be observed!
// Also Factories and CommandInterpreter are not required!
IChampionshipController championshipController = new ChampionshipController(
motorcycleRepository,
raceRepository,
riderRepository,
motorcycleFactory);
ICommandInterpreter commandInterpreter = new CommandInterpreter(championshipController);
IEngine engine = new Engine(commandInterpreter, reader, writer);
engine.Run();
}
/// <summary>
///Get geo definitions
/// </summary>
/// <returns></returns>
public List <GeoDefinitionDTO> GetGeoDefinitions()
{
List <GeoDefinitionDTO> result = new List <GeoDefinitionDTO>();
ObjectMapper.Map(RaceRepository.GetGeoDefinitions(), result);
return(result);
}
public RaceView()
{
InitializeComponent();
var mainWindow = (MainWindow)Application.Current.MainWindow;
_rfidManager = mainWindow.RfidManager;
_reportManager = mainWindow.ReportManager;
_race = new Race();
rbRaceName.DataContext = _race;
this.DataContext = _rfidManager;
// btnSetTimer.IsEnabled = _rfidManager.Connected;
btnStartTimer.IsEnabled = false;
btnStopTimer.IsEnabled = false;
// ttbTimer.IsStarted = false;
_raceRepository = new RaceRepository();
this.Show.Text = _raceTime.ToString("HH:mm:ss:ff");
//this.ReportTags.Text = _rfidManager.ReportTags;
dgSplits.ItemsSource = _rfidManager.AthleteSplits;
// btnStartTimer.IsEnabled = RfidManager.Connected;
}
public CharacterBuilder(RaceRepository raceRepository, ClassRepository classRepository, IStatsComputer statsComputer, IRandomizer randomizer)
{
RaceRepository = raceRepository;
ClassRepository = classRepository;
StatsComputer = statsComputer;
Randomizer = randomizer;
}
public void Simple_Status_Race()
{
IElectionRepository electionRepository = Substitute.For <IElectionRepository>();
var f = new Fixture();
var election = f.Create <Election>();
var race = Create(election.GetMasterDataRef());
electionRepository.GetById(Arg.Any <Guid>()).Returns(election);
var raceRepository = new RaceRepository(ContextConnection(), electionRepository);
raceRepository.Save(race);
raceRepository.SetInactive(race);
var inactive = raceRepository.GetById(race.Id);
Assert.That(inactive.Status == EntityStatus.Inactive);
raceRepository.SetActive(race);
var active = raceRepository.GetById(race.Id);
Assert.That(active.Status == EntityStatus.Active);
raceRepository.SetAsDeleted(race);
var deleted = raceRepository.GetById(race.Id);
Assert.That(deleted.Status == EntityStatus.Deleted);
}
public void Test_EnterRaceResultsToNonExistingRace()
{
RaceRepository raceRepository = RaceRepository.GetInstance();
RaceResults raceResults = new RaceResults(driverRepository.GetAllActiveDrivers(), driverRepository.GetDriverByGoKart(16));
raceRepository.EnterResults("AusGP", raceResults);
}
public void ViewFinishedRaces(IMainController _mainController, IShowFinishedRacesView inForm)
{
RaceRepository _raceRepository = RaceRepository.GetInstance();
List <Race> finRaces = _raceRepository.GetAllFinishedRaces();
inForm.ShowModaless(_mainController, finRaces);
}
public UnitOfWork(RaceManagerDbContext context)
{
_context = context;
Races = new RaceRepository(_context);
Drivers = new DriverRepository(_context);
Vehicles = new VehicleRepository(_context);
Users = new UserRepository(_context);
}
public void ViewUpcomingRaces(IMainController _mainController, IShowUpcomingRacesView inForm)
{
RaceRepository _raceRepository = RaceRepository.GetInstance();
List <Race> upRaces = _raceRepository.GetAllUnfinishedRaces();
inForm.ShowModaless(_mainController, upRaces);
}
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 void AddRaceToRepository()
{
Player player = new Player();
Race race = new Race(1, 2, player);
bool successful = RaceRepository.Add(race);
Assert.True(successful, "The race was not added successfully to the repository.");
}
public RaceController()
{
context = new ApplicationDbContext();
planetRepository = new PlanetRepository(context);
raceClassificationRepository = new RaceClassificationRepository(context);
raceRepository = new RaceRepository(context);
unitOfWork = new UnitOfWork(context);
filePathRepository = new FilePathRepository(context);
}
public void Test_AddingSameRaceReferenceTwice()
{
RaceRepository raceRepository = RaceRepository.GetInstance();
Race race = new Race(raceRepository.GetNewID(), "BahGP", new DateTime(2020, 3, 22), trackRepository.GetTrackByName("Bahrein International Circuit"));
raceRepository.AddRace(race);
raceRepository.AddRace(race);
}
public void FindRaceByRefereeTest()
{
IDictionary <string, string> props = new SortedList <string, string>();
props.Add("ConnectionString", "server=localhost;user=root;database=mpp;port=3306;password=root");
RaceRepository repository = new RaceRepository(props);
Race race = repository.FindRaceByReferee("jane");
Assert.AreEqual(race.Name, "swimming");
}
public RacesController()
{
context = new ApplicationDbContext();
raceRepository = new RaceRepository(context);
ticketRepository = new TicketRepository(context);
orderRepository = new OrderRepository(context);
filePathRepository = new FilePathRepository(context);
fileManager = new FileManager(HostingEnvironment.MapPath("~/App_Assets/"));
unitOfWork = new UnitOfWork(context);
}
public ChampionshipController()
{
this.raceFactory = new RaceFactory();
this.riderFactory = new RiderFactory();
this.motorcycleFactory = new MotorcycleFactory();
this.motorcycleRepository = new MotorcycleRepository();
this.raceRepository = new RaceRepository();
this.riderRepository = new RiderRepository();
}
public ChampionshipController()
{
motorcycleRepo = new MotorcycleRepository();
raceRepo = new RaceRepository();
riderRepo = new RiderRepository();
motorcycleFactory = new MotorcycleFactory();
raceFactory = new RaceFactory();
riderFactory = new RiderFactory();
}
public List <AuditSummarySearchDTO> GetSearchAuditdata(AuditSearchDTO auditSearchDTO, long userID, long RoleID)
{
List <AuditSummarySearchDTO> result = new List <AuditSummarySearchDTO>();
AuditSearch request = new AuditSearch();
ObjectMapper.Map(auditSearchDTO, request);
ObjectMapper.Map(RaceRepository.GetSearchAuditdata(request, userID, RoleID), result);
return(result);
}
public OrderController()
{
context = new ApplicationDbContext();
ticketRepository = new TicketRepository(context);
orderRepository = new OrderRepository(context);
raceRepository = new RaceRepository(context);
planetRepository = new PlanetRepository(context);
flightSeatRepository = new FlightSeatRepository(context);
unitOfWork = new UnitOfWork(context);
}
public void Testar_Instance()
{
//Arrange.
//Act.
RaceRepository repository = new RaceRepository(this.CreateContext());
//Assert.
Assert.IsNotNull(repository);
}
public void Add_Car_To_Race_That_Is_Full_Returns_False()
{
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 = 1,
Name = "Huge Lane",
LengthInMeters = 1000,
MaxCars = 1
};
var race = new Race()
{
Id = 1,
TrackId = 1,
Track = track,
NumberOfLaps = 2,
};
var car = new Car()
{
Id = 1, Name = "BMW", Driver = "Hugh Hefner"
};
var car2 = new Car()
{
Id = 2, Name = "Opel", Driver = "Barack Obama"
};
var raceCar = new CarInRace()
{
CarId = car.Id,
RaceId = race.Id,
Car = car,
Race = race
};
_context.Cars.Add(car);
_context.Cars.Add(car2);
_context.Races.Add(race);
_context.CarsInRace.Add(raceCar);
_context.SaveChanges();
using (var repository = new RaceRepository(_context))
{
var result = repository.AddCarToRace(2, 1);
Assert.False(result.ok);
Assert.Equal("Race is full", result.error);
}
connection.Close();
}
private void AddRacers(PinewoodDerby.DataAccess.Models.Race race, int howMany)
{
for (int i = 0; i < howMany; i++)
{
PinewoodDerby.DataAccess.Models.Racer racer = new PinewoodDerby.DataAccess.Models.Racer()
{
Firstname = "Racer",
Lastname = i.ToString(),
Den = "0",
Race = race
};
race.Racers.Add(racer);
}
using (NHibernateUnitOfWork.UnitOfWork.Start())
{
IRaceRepository repository = new RaceRepository();
repository.Add(race);
}
}
private void PopulateToolsetViewModel()
{
ClearViewModelPopulation();
using (GameModuleRepository repo = new GameModuleRepository())
{
ViewModel.ActiveModule = repo.GetModule();
}
using (ContentPackageResourceRepository repo = new ContentPackageResourceRepository())
{
ViewModel.TilesetSpriteSheetsList = repo.GetAllUIObjects(ContentPackageResourceTypeEnum.Tileset, false);
}
using (ItemRepository repo = new ItemRepository())
{
ViewModel.ItemList = repo.GetAllUIObjects();
}
using (ScriptRepository repo = new ScriptRepository())
{
ViewModel.ScriptList = repo.GetAllUIObjects();
}
using (GenderRepository repo = new GenderRepository())
{
ViewModel.GenderList = repo.GetAllUIObjects();
}
using (ConversationRepository repo = new ConversationRepository())
{
ViewModel.ConversationList = repo.GetAllUIObjects();
}
using (RaceRepository repo = new RaceRepository())
{
ViewModel.RaceList = repo.GetAllUIObjects();
}
using (FactionRepository repo = new FactionRepository())
{
ViewModel.FactionList = repo.GetAllUIObjects();
}
using (TilesetRepository repo = new TilesetRepository())
{
ViewModel.TilesetList = repo.GetAllUIObjects();
}
using (AbilityRepository repo = new AbilityRepository())
{
ViewModel.AbilityList = repo.GetAll();
}
using (SkillRepository repo = new SkillRepository())
{
ViewModel.SkillList = repo.GetAll();
}
using (LevelRequirementRepository repo = new LevelRequirementRepository())
{
ViewModel.LevelRequirementList = repo.GetAll();
}
}
