public void Setup()
{
IDictionary <object, object> Properties = new Dictionary <object, object>();
var context = new HostBuilderContext(Properties)
{
HostingEnvironment = mockEnvironment.Object
};
var mockBuilder = new Mock <IHostBuilder>();
mockBuilder.Setup(x =>
x.ConfigureAppConfiguration(It.IsAny <Action <HostBuilderContext, IConfigurationBuilder> >()))
.Callback((Action <HostBuilderContext, IConfigurationBuilder> x) =>
x.Invoke(context, mockConfigurationBuilder.Object));
mockBuilder.Setup(x => x.ConfigureServices(It.IsAny <Action <IServiceCollection> >()))
.Returns(mockBuilder.Object);
var mockSet = new Mock <DbSet <Car> >();
mockSet.As <IQueryable <Car> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Car> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Car> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Car> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <ParkingContext>();
mockContext.Setup(c => c.Cars).Returns(mockSet.Object);
_parkingService = new ParkingService(mockContext.Object);
}
public void SuccessfullyCreatedALot()
{
ParkingService svc = new ParkingService();
string lotNumber = "6";
Assert.Equal($"Created a parking lot with {lotNumber} slots\n", svc.CreateParkingLot(lotNumber));
}
public ParkingServiceTests()
{
_withdrawTimer = new FakeTimerService();
_logTimer = new FakeTimerService();
_logService = A.Fake <ILogService>();
_parkingService = new ParkingService(_withdrawTimer, _logTimer, _logService);
}
public void GetAllParkingSpaces()
{
var parkingService = new ParkingService(CreateParking(20, 5, 40, 10, 1, 24));
var result = parkingService.GetAllParkingSpaces();
Assert.NotEmpty(result);
}
public void GetStatusNoData()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("1");
Assert.Equal($"Slot No.\tRegistration No\t\tColour\n\n", svc.GetStatus());
}
public void GetAllVacantSpaces(int jumboV, int jumboO, int jetV, int jetO, int propV, int propO, int expected)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
var result = parkingService.GetAllVacantParkingSpaces();
Assert.Equal(expected, result.Count);
}
public void InsertNonNumberValue()
{
ParkingService svc = new ParkingService();
string slotNumber = "abc";
Assert.Equal($"Error in converting number {slotNumber}\n", svc.Leave(slotNumber));
}
public ConviveController()
{
_context = new Context();
_eventService = new EventService(new EventRepository(_context), new ImageRepository(_context));
_parkingService = new ParkingService(new ParkingRepository(_context));
_imageService = new ImageService(new ImageRepository(_context));
}
public void GetAllVacantParkingSpacesByType(int jumboV, int jumboO, int jetV, int jetO, int propV, int propO, int expected, PlaneType planeType)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
var result = parkingService.GetAllVacantParkingSpacesForType(planeType);
Assert.Equal(expected, result.Count());
}
public void AssertExceptionThrownWhenNoSpaceFound(int jumboV, int jumboO, int jetV, int jetO, int propV,
int propO, PlaneType planeType)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
Assert.Throws <ParkingSpaceException>(() => parkingService.ParkPlaneInFirstSlot(planeType));
}
public static ParkedVehical ParkVehical(ParkingService parkingService)
{
ParkedVehical vehical = new ParkedVehical();
Console.WriteLine("Please enter details");
Console.Write("Vehical Type : ");
var type = parkingService.ParkingAvailable(Console.ReadLine());
if (type >= 1)
{
Console.Write("Vehical number : ");
vehical.VehicalNumber = Console.ReadLine();
if (parkingService.ParkingStatus(vehical.VehicalNumber) == null)
{
vehical.ParkingLot = type;
return(vehical);
}
else
{
Console.WriteLine(vehical.VehicalNumber + " already parked in parking");
return(null);
}
}
else
{
Console.WriteLine("For this vehical parking is not available");
return(null);
}
}
public static void Main(string[] args)
{
svc = new ParkingService();
if (args.Length > 0)
{
// get command
string cmd1 = args[0];
// run the app with file
string filename = "";
if (cmd1.Split(".").Length > 0)
{
filename = cmd1;
using (StreamReader reader = new StreamReader(filename))
{
while (reader.Peek() > 0)
{
string input = reader.ReadLine();
RunningApp(input);
}
}
}
}
else
{
// run interactively
while (true)
{
string input = Console.ReadLine();
RunningApp(input);
}
}
}
public void InsertNonNumberValue()
{
ParkingService svc = new ParkingService();
string lotNumber = "abc";
Assert.Equal($"Error in converting number {lotNumber}\n", svc.CreateParkingLot(lotNumber));
}
public ParkingManager(Form mdiParent)
{
_parkingService = new ParkingService();
_sessionParkings = new List <Parking>();
InitializeComponent();
MdiParent = mdiParent;
}
public void GetAllPossibleVacantParkingSpaces(int jumboV, int jumboO, int jetV, int jetO, int propV, int propO, int expected, PlaneType planeType, PlaneType expectedPlaneType)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
var result = parkingService.GetAllPossibleVacantParkingSpaces(planeType);
Assert.Equal(expected, result.Count());
Assert.Equal(expectedPlaneType, result.First().PlaneType);
}
public void GetAllPossibleVacantParkingSpacesReturnsEmpty(int jumboV, int jumboO, int jetV, int jetO, int propV,
int propO, PlaneType planeType)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
var result = parkingService.GetAllPossibleVacantParkingSpaces(planeType);
Assert.Empty(result);
}
public void NotFound()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("1");
Assert.Equal("Not found\n", svc.GetRegistrationNumbersByColour("White"));
}
public void NotFound()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("1");
Assert.Equal("Not found\n", svc.GetSlotNumberByRegistrationNumber("REG-01"));
}
public void SuccessfullyParked()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("1");
Assert.Equal($"Allocated slot number: 1\n", svc.Park("1", "1"));
}
public void ParkingFull()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("1");
svc.Park("1", "1");
Assert.Equal($"Sorry, parking lot is full\n", svc.Park("2", "2"));
}
public void SuccessfullyLeave()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("1");
svc.Park("1", "1");
Assert.Equal($"Slot number 1 is free\n", svc.Leave("1"));
}
public static int ReleaseVehical(ParkingService parkingService)
{
ParkedVehical vehical = new ParkedVehical();
Console.Write("Please enter vehical number : ");
vehical.VehicalNumber = Console.ReadLine();
int id = parkingService.GetVehicalId(vehical.VehicalNumber);
return(id);
}
public void OneFound()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("2");
svc.Park("REG-01", "White");
svc.Park("REG-02", "Black");
Assert.Equal("2\n", svc.GetSlotNumberByRegistrationNumber("REG-02"));
}
public void TwoDataFound()
{
ParkingService svc = new ParkingService();
svc.CreateParkingLot("2");
svc.Park("REG-01", "White");
svc.Park("REG-02", "White");
Assert.Equal("1, 2\n", svc.GetSlotNumbersByColour("White"));
}
public ParkingController(ParkingService service)
{
this.service = service;
if (service.parking.Cars.Count == 0)
{
service.parking.Cars.Add(new Car(CarType.Passenger, 20));
service.parking.Cars.Add(new Car(CarType.Bus, 100));
service.parking.Cars.Add(new Car(CarType.Truck, 200));
}
}
public void Parking_IsSingelton()
{
var newParkingService = new ParkingService(_withdrawTimer, _logTimer, _logService);
var vehicle = new Vehicle("AA-0001-AA", VehicleType.Truck, 100);
_parkingService.AddVehicle(vehicle);
Assert.Single(newParkingService.GetVehicles());
Assert.Single(_parkingService.GetVehicles());
Assert.Same(_parkingService.GetVehicles()[0], newParkingService.GetVehicles()[0]);
}
public void ParkVehicleDefaultArrangeTest()
{
// arrange
var period = new RentPeriod(10, 1);
// act
var actualResult = new ParkingService().ParkVehicle(period);
// assert
Assert.AreEqual(170, actualResult);
}
public void AssertExceptionThrownWhenSpaceAlreadyOccupied(int jumboV, int jumboO, int jetV, int jetO, int propV,
int propO, PlaneType planeType)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
var space = parkingService.GetFirstPossiblePlaneParkingSpace(planeType);
space.SpaceStatus = SpaceStatus.Occupied;
Assert.Throws <ParkingSpaceException>(() => parkingService.ParkPlaneBySpaceId(space.SpaceId));
}
public void DeleteParking_True(int id)
{
var mockParkingRepository = new Mock <IParkingRepository>();
var mockEspacioRepository = new Mock <IEspacioRepository>();
mockParkingRepository.Setup(sp => sp.Delete(id)).Returns(true);
IParkingService parkingService = new ParkingService(mockParkingRepository.Object, mockEspacioRepository.Object);
var resultado = parkingService.Delete(id);
Assert.True(resultado);
}
public void TestUnParking(int jumboV, int jumboO, int jetV, int jetO, int propV,
int propO, PlaneType planeType)
{
var parkingService = new ParkingService(CreateParking(jumboV, jumboO, jetV, jetO, propV, propO));
var spaces = parkingService.GetAllPossibleVacantParkingSpaces(planeType);
var space = parkingService.GetFirstPossiblePlaneParkingSpace(planeType);
space.SpaceStatus = SpaceStatus.Vacant;
Assert.Throws <ParkingSpaceException>(() => parkingService.UnParkPlaneBySpaceId(space.SpaceId));
}
public void WhenMultipleCarsParked_ThenCorrectStatisticsCalculated()
{
//arrage
var startTimes = new List<DateTime>
{
new DateTime(2015, 6, 1, 0, 0, 0), //June 1st 2015 00:00
new DateTime(2015, 7, 1, 0, 0, 0), //July 1st 2015 00:00
new DateTime(2015, 7, 2, 0, 0, 0), //July 2nd 2015 00:00
new DateTime(2015, 7, 6, 0, 0, 0) //July 6th 2015 00:00
};
var endTimes = new List<DateTime>
{
new DateTime(2015, 6, 1, 1, 0, 0), //June 1st 2015 01:00
new DateTime(2015, 7, 1, 2, 15, 0), //July 1st 2015 02:15
new DateTime(2015, 7, 2, 3, 15, 0), //July 2nd 2015 03:15
new DateTime(2015, 7, 6, 1, 15, 0), //July 6th 2015 01:15
};
var car1 = new Car("123ABC");
var car2 = new Car("223ABC");
var car3 = new Car("323ABC");
var parkingRepository = new MockParkingRepository(new HashSet<Parking>(), startTimes, endTimes);
var contractRepository = new MockParkingContractRepository(new List<IVehicle> { car1 });
var invoiceRepository = new MockParkingInvoiceRepository(new List<ParkingInvoice>());
var parkingService = new ParkingService(parkingRepository, contractRepository, invoiceRepository);
var garage = new ParkingGarage(parkingService);
//act
garage.StartParking(car1); //June 1st 2015 00:00
garage.StopParking(car1); //June 1st 2015 01:00
garage.StartParking(car2); //July 1st 2015 00:00
garage.StopParking(car2); //July 1st 2015 02:15
garage.StartParking(car3); //July 2nd 2015 00:00
garage.StopParking(car3); //July 2nd 2015 03:15
garage.StartParking(car1); //July 6th 2015 00:00
garage.StopParking(car1); //July 6th 2015 01:15
//assert
Assert.AreEqual(garage.TotalNumberOfParkedCars, 3);
//1st parking - 1h
//2nd parking - 3h
//3rd parking - 4h
//4th parking - 2h
//PricePerHour = 5
Assert.AreEqual(garage.TotalInvoicedAmount, 50);
}
