public void GivenGetAllParkingLots_WhenRequestingAllParkingLots_ThenReturnListOfAllParkingLots()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
var parkingLot1 = ParkingLotBuilder.CreateNewParkingLot()
.WithName("test")
.WithAddress(Address.CreateAddress("Parkinglotstraat", "20a", city))
.WithContactPerson(ContactPerson.CreateNewContactPerson("Bas", "Adriaans", Address.CreateAddress("Contactpersoonstraat", "30", city), "*****@*****.**", "000000", ""))
.WithCapacity(20)
.WithDivision(Guid.NewGuid())
.WithPricePerHour(4.5m)
.Build();
var parkingLot2 = ParkingLotBuilder.CreateNewParkingLot()
.WithName("test2")
.WithAddress(Address.CreateAddress("Parkinglotstraat", "20a", city))
.WithContactPerson(ContactPerson.CreateNewContactPerson("Bas", "Adriaans", Address.CreateAddress("Contactpersoonstraat", "30", city), "*****@*****.**", "000000", ""))
.WithCapacity(20)
.WithDivision(Guid.NewGuid())
.WithPricePerHour(4.5m)
.Build();
context.Set <ParkingLot>().Add(parkingLot1);
context.Set <ParkingLot>().Add(parkingLot2);
context.SaveChanges();
var service = new ParkingLotService(context);
var result = context.ParkingLots.CountAsync();
Assert.Equal(2, result.Result);
}
}
public void GivenGetSingleParkingLot_WhenRequestingSingleParkingLot_ReturnRequestedParkingLot()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
var service = new ParkingLotService(context);
var parkingLot = ParkingLotBuilder.CreateNewParkingLot()
.WithName("test")
.WithAddress(Address.CreateAddress("Parkinglotstraat", "20a", city))
.WithContactPerson(ContactPerson.CreateNewContactPerson("Bas", "Adriaans", Address.CreateAddress("Contactpersoonstraat", "30", city), "*****@*****.**", "000000", ""))
.WithCapacity(20)
.WithDivision(Guid.NewGuid())
.WithPricePerHour(4.5m)
.Build();
context.Set <ParkingLot>().Add(parkingLot);
var id = parkingLot.ParkingLotID;
context.SaveChanges();
var result = service.GetSingleParkingLot(id);
Assert.IsType <ParkingLot>(result);
Assert.Equal(id, result.ParkingLotID);
Assert.Equal("test", result.Name);
}
}
protected virtual async Task ProvideTestData(ParkSharkDbContext context)
{
await context.Divisions.AddAsync(new Division("First", "First", "Mr Test"));
await context.SaveChangesAsync();
await context.Divisions.AddAsync(new Division("Second", "Second", "Mr Test2"));
await context.SaveChangesAsync();
await context.Set <BuildingType>().AddAsync(new BuildingType(nameof(BuildingTypes.Underground)));
await context.SaveChangesAsync();
await context.Set <BuildingType>().AddAsync(new BuildingType(nameof(BuildingTypes.Aboveground)));
await context.SaveChangesAsync();
await context.Set <MemberShipLevel>().AddAsync(new MemberShipLevel(MemberShipLevel.Level.Bronze, 0, 0, 240));
await context.Set <MemberShipLevel>().AddAsync(new MemberShipLevel(MemberShipLevel.Level.Silver, 10, 20, 360));
await context.Set <MemberShipLevel>().AddAsync(new MemberShipLevel(MemberShipLevel.Level.Gold, 40, 30, 1440));
await context.SaveChangesAsync();
}
public static void AssemblyInit(TestContext testContext)
{
var options = new DbContextOptionsBuilder <ParkSharkDbContext>()
.UseSqlServer(GetConfiguration().GetConnectionString("ParkSharkDb"))
.Options;
using (var context = new ParkSharkDbContext(options))
{
PurgeDbAndAddTestDataFromFile(context);
}
}
public void GivenADivision_WhenAssigningSelfAsParentDivision_ParentDivisionRemainsNull()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var division = Division.CreateNewDivision("name", "orgname", "director");
var divisionService = new DivisionService(context);
var result = divisionService.AssignParentDivision(division, division);
Assert.Null(division.ParentDivisionID);
Assert.Null(result);
}
}
public void GivenHappyPath1_WhenAddingNewDivisionToDb_ObjectIsFlushedAndReturned()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var division = Division.CreateNewDivision("test", "testorg", "lars");
var divisionService = new DivisionService(context);
var result = divisionService.CreateDivision(division);
Assert.IsType <Division>(result);
}
}
public void GivenHappyPath2_WhenAddingNewDivisionToDb_ObjectIsAddedToDb()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var division = Division.CreateNewDivision("test", "testorg", "lars");
var divisionService = new DivisionService(context);
var result = divisionService.CreateDivision(division);
Assert.Single(divisionService.GetAllDivisions());
}
}
public void GivenGetAllDivisions_WhenRequestingAllDivisions_ThenReturnListOfAllDivisions()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
context.Set <Division>().Add(Division.CreateNewDivision("test", "testorg", "lars"));
context.Set <Division>().Add(Division.CreateNewDivision("test2", "testorg2", "lars"));
context.SaveChanges();
var divisionService = new DivisionService(context);
var result = divisionService.GetAllDivisions().Count;
Assert.Equal(2, result);
}
}
public void GivenGetSingleParkingLotUnHappyPath_WhenRequestingSingleParkingLot_ReturnNull()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var service = new ParkingLotService(context);
var id = new Guid();
var result = service.GetSingleParkingLot(id);
Assert.Null(result);
}
}
protected override void ConfigureAdditionalServices(IServiceCollection services)
{
var connectionString = Configuration.GetConnectionString("ParkSharkDb");
services.UseAllOfType <IParkSharkService>(new[] { typeof(ParkShark.Services.Assembly).Assembly }, ServiceLifetime.Transient);
//Register all ApiControllers from our Web project
services.AddMvc().AddApplicationPart(typeof(Startup).Assembly);
//Add a singleton DbConnection (one per test)
services.AddSingleton <DbConnection>((serviceProvider) =>
{
var dbConnection = new SqlConnection(connectionString);
dbConnection.Open();
return(dbConnection);
});
//Add a singleton Transaction (one per test)
services.AddSingleton <DbTransaction>((serviceProvider) =>
{
var dbConnection = serviceProvider
.GetService <DbConnection>();
return(dbConnection.BeginTransaction(IsolationLevel.ReadCommitted));
});
//Create DbOptions for the DbContext, use the DbConnection
//This is done for every request/response
services.AddScoped <DbContextOptions>((serviceProvider) =>
{
var dbConnection = serviceProvider.GetService <DbConnection>();
return(new DbContextOptionsBuilder <ParkSharkDbContext>()
.UseSqlServer(dbConnection)
.Options);
});
//Finally, create the DbContext, using the one singleton transaction
//This is done for every time a DbContext is requested (could be more than once per request/response)
services.AddScoped <ParkSharkDbContext>((serviceProvider) =>
{
var options = serviceProvider.GetService <DbContextOptions>();
var transaction = serviceProvider.GetService <DbTransaction>();
var context = new ParkSharkDbContext(options);
context.Database.UseTransaction(transaction);
return(context);
});
services.AddSingleton(new Mapper());
}
public void GivenADivision_WhenAssigningAnAlreadyAssignedSubDivision_ThenReturnsNull()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
//given
var parentDivision = Division.CreateNewDivision("name", "orgname", "director");
var subDivision = Division.CreateNewDivision("name", "orgname", "director");
parentDivision.SubdivisionsList.Add(subDivision);
var divisionService = new DivisionService(context);
var result = divisionService.AssignParentDivision(subDivision, parentDivision);
Assert.Null(result);
}
}
public void GivenADivision_WhenAssigningParentDivisonToADivisionThatAlreadyHasAParentDivision_ThenReturnsNull()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var division = Division.CreateNewDivision("name", "orgname", "director");
var parentDivision = Division.CreateNewDivision("name", "orgname", "director");
var secondParentDivsion = Division.CreateNewDivision("name", "orgname", "director");
division.ParentDivisionID = parentDivision.DivisionID;
division.ParentDivision = parentDivision;
var divisionService = new DivisionService(context);
var result = divisionService.AssignParentDivision(division, secondParentDivsion);
Assert.Null(result);
}
}
protected override async Task ProvideTestData(ParkSharkDbContext context)
{
await base.ProvideTestData(context);
var parkinglot = new ParkingLot("One spot", 1,
new Contact("Pl1", "124", "555", "*****@*****.**", new Address("street", "45", "555", "Test")), 1,
50m, 2);
await context.ParkingLots.AddAsync(parkinglot);
var member1 = new Member(new Contact("Pl1", "124", "555", "*****@*****.**", new Address("street", "45", "555", "Test")), new LicensePlate("VXK014", "BE"), DateTime.Now, MemberShipLevel.Level.Bronze);
var member2 = new Member(new Contact("Pl1", "124", "555", "*****@*****.**", new Address("street", "45", "555", "Test")), new LicensePlate("VXK019", "BE"), DateTime.Now, MemberShipLevel.Level.Bronze);
await context.Members.AddAsync(member1);
await context.Members.AddAsync(member2);
await context.SaveChangesAsync();
}
protected override async Task ProvideTestData(ParkSharkDbContext context)
{
await base.ProvideTestData(context);
await context.Members.AddAsync(new Member(
new Contact("Maarten Merken", "+3255511144", String.Empty, "*****@*****.**",
new Address("Test", "15A", "1000", "Brussel")), new LicensePlate("VXK014", "BE"),
DateTime.Now.AddYears(-15)));
await context.SaveChangesAsync();
await context.Members.AddAsync(new Member(
new Contact("John Doe", "+3255511144", String.Empty, "*****@*****.**",
new Address("Streety", "55", "3500", "Hasselt")), new LicensePlate("155542D4", "US"),
DateTime.Now.AddYears(-1)));
await context.SaveChangesAsync();
}
public void GivenGetAllMembers_WhenRequestingAllMembers_ThenReturnListOfAllMembers()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var memberShipLevel = new MembershipLevel();
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
context.Set <Member>().Add(Member.CreateMember("lars", "Peelman", Address.CreateAddress("test", "5", city), MembershipLevelEnum.Bronze, memberShipLevel));
context.Set <Member>().Add(Member.CreateMember("laeeers", "ee", Address.CreateAddress("test", "5", city), MembershipLevelEnum.Bronze, memberShipLevel));
context.SaveChanges();
var service = new MemberService(context);
var result = service.GetAllMembers().Count;
Assert.Equal(2, result);
}
}
internal async Task <UnitTestContext> NewParkSharkInMemoryTestContext()
{
var context = new ParkSharkDbContext(CreateNewInMemoryDatabaseOptions());
var mapper = new Mapper();
ConfigureMappings(mapper);
context.ResetValueGenerators();
await ProvideTestData(context);
return(new UnitTestContext
{
ParkSharkDbContext = context,
Mapper = mapper
});
}
public static void UseSqlServer(this IServiceCollection serviceCollection, string connectionString, ILoggerFactory loggerFactory, IsolationLevel level = IsolationLevel.ReadUncommitted)
{
//First, configure the SqlConnection and open it
//This is done for every request/response
serviceCollection.AddScoped <DbConnection>((serviceProvider) =>
{
var dbConnection = new SqlConnection(connectionString);
dbConnection.Open();
return(dbConnection);
});
//Start a new transaction based on the SqlConnection
//This is done for every request/response
serviceCollection.AddScoped <DbTransaction>((serviceProvider) =>
{
var dbConnection = serviceProvider
.GetService <DbConnection>();
return(dbConnection.BeginTransaction(level));
});
//Create DbOptions for the DbContext, use the DbConnection
//This is done for every request/response
serviceCollection.AddScoped <DbContextOptions>((serviceProvider) =>
{
var dbConnection = serviceProvider.GetService <DbConnection>();
return(new DbContextOptionsBuilder <ParkSharkDbContext>()
.UseSqlServer(dbConnection)
.UseLoggerFactory(loggerFactory)
.Options);
});
//Finally, create the DbContext, using the transaction
//This is done for every time a DbContext is requested (could be more than once per request/response)
serviceCollection.AddScoped <ParkSharkDbContext>((serviceProvider) =>
{
var transaction = serviceProvider.GetService <DbTransaction>();
var options = serviceProvider.GetService <DbContextOptions>();
var context = new ParkSharkDbContext(options);
context.Database.UseTransaction(transaction);
return(context);
});
}
public void GivenGetSingleMemberUnHappyPath_WhenRequestingSingleMember_ReturnNull()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var service = new MemberService(context);
var memberShipLevel = new MembershipLevel();
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
var member = Member.CreateMember("lars", "Peelman", Address.CreateAddress("test", "5", city), MembershipLevelEnum.Gold, memberShipLevel);
context.Set <Member>().Add(member);
context.SaveChanges();
var fakeID = Guid.NewGuid();
var result = service.GetMember(fakeID);
Assert.Null(result);
}
}
public void GivenGetSingledivisionUnHappyPath_WhenRequestingSingleDivision_ReturnNull()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var divisionService = new DivisionService(context);
var division = Division.CreateNewDivision("test", "testorg", "lars");
context.Set <Division>().Add(division);
var fakeID = Guid.NewGuid();
context.SaveChanges();
var result = divisionService.GetSingleDivision(fakeID);
Assert.Null(result);
}
}
public void GivenGetSingledivision_WhenRequestingSingleDivision_ReturnRequestedDivision()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var divisionService = new DivisionService(context);
var division = Division.CreateNewDivision("test", "testorg", "lars");
context.Set <Division>().Add(division);
var divsionID = division.DivisionID;
context.SaveChanges();
var result = divisionService.GetSingleDivision(divsionID);
Assert.IsType <Division>(result);
Assert.Equal(divsionID, result.DivisionID);
Assert.Equal("test", result.Name);
Assert.Equal("testorg", result.OriginalName);
}
}
public void GivenHappyPath2_WhenAddingNewParkingLotToDb_ObjectIsAddedToDb()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
var parkingLot = ParkingLotBuilder.CreateNewParkingLot()
.WithName("test")
.WithAddress(Address.CreateAddress("Parkinglotstraat", "20a", city))
.WithContactPerson(ContactPerson.CreateNewContactPerson("Bas", "Adriaans", Address.CreateAddress("Contactpersoonstraat", "30", city), "*****@*****.**", "000000", ""))
.WithCapacity(20)
.WithDivision(Guid.NewGuid())
.WithPricePerHour(4.5m)
.Build();
var service = new ParkingLotService(context);
var result = service.CreateParkingLot(parkingLot);
Assert.Single(context.ParkingLots);
}
}
private async Task AllocationTestData(ParkSharkDbContext context)
{
await context.Allocations.AddAsync(new Allocation(1, 1, new LicensePlate("VXK014", "BE"), DateTime.Now.AddDays(-5)));
await context.Allocations.AddAsync(new Allocation(1, 1, new LicensePlate("VXK014", "BE"), DateTime.Now.AddDays(-4)));
await context.Allocations.AddAsync(new Allocation(2, 1, new LicensePlate("VXK019", "BE"), DateTime.Now.AddDays(-3)));
var stopped1 = new Allocation(2, 1, new LicensePlate("VXK019", "BE"), DateTime.Now.AddDays(-2));
stopped1.EndDateTime = DateTime.Now.AddDays(-2);
var stopped2 = new Allocation(2, 1, new LicensePlate("VXK019", "BE"), DateTime.Now.AddDays(-1));
stopped2.EndDateTime = DateTime.Now.AddDays(-1);
await context.Allocations.AddAsync(stopped1);
await context.Allocations.AddAsync(stopped2);
await context.Allocations.AddAsync(new Allocation(1, 1, new LicensePlate("VXK014", "BE"), DateTime.Now));
await context.SaveChangesAsync();
}
public void Given2Divisions_WhenAssigningParentTOSUb_SubdevisionIsReturnedWithParentGuidID()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var divisionService = new DivisionService(context);
var name = "Test1";
var originalName = "Test1";
string director = "test1";
var parentDivision = Division.CreateNewDivision(name, originalName, director);
divisionService.CreateDivision(parentDivision);
var subDivision = Division.CreateNewDivision(name, originalName, director);
divisionService.CreateDivision(subDivision);
var result = divisionService.AssignParentDivision(subDivision, parentDivision);
Assert.Equal(parentDivision.DivisionID, subDivision.ParentDivisionID);
Assert.Single(parentDivision.SubdivisionsList);
}
}
public void GivenGetSingleMember_WhenRequestingSingleMember_ReturnRequestedMember()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
var service = new MemberService(context);
var memberShipLevel = new MembershipLevel();
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
var member = Member.CreateMember("lars", "Peelman", Address.CreateAddress("test", "5", city), MembershipLevelEnum.Gold, memberShipLevel);
context.Set <Member>().Add(member);
context.SaveChanges();
var id = member.MemberId;
var result = service.GetMember(id);
Assert.IsType <Member>(result);
Assert.Equal(id, result.MemberId);
Assert.Equal("lars", result.FirstName);
Assert.Equal("Peelman", result.LastName);
}
}
public void GivenHappyPath2_WhenAddingNewMemberToDb_ObjectIsAddedToDb()
{
using (var context = new ParkSharkDbContext(CreateNewInMemoryDatabase()))
{
context.Set <MembershipLevel>().Add(new MembershipLevel()
{
MemberShipLevelId = 0, Name = "Bronze", MonthlyCost = 0, PSAPriceReductionPercentage = 0, PSAMaxTimeInHours = new TimeSpan(4, 0, 0)
});
context.SaveChanges();
var city = City.CreateCity(2050, "Antwerpen", "Belgium");
var member = new DummyMemberObject()
{
FirstName = "lars", LastName = "Peelman", Address = Address.CreateAddress("test", "5", city), MembershipLevel = MembershipLevelEnum.Bronze
};
var service = new MemberService(context);
var result = service.CreateNewMember(member);
Assert.Single(service.GetAllMembers());
}
}
public MemberService(ParkSharkDbContext memberDBContext)
{
_parkSharkDBContext = memberDBContext;
}
public MemberService(ParkSharkDbContext context)
{
this.context = context;
}
public AllocationService(ParkSharkDbContext context, IMemberService memberService, IParkingLotService parkingLotService)
{
this.context = context;
this.memberService = memberService;
this.parkingLotService = parkingLotService;
}
public ParkingLotService(ParkSharkDbContext context)
{
_context = context;
}
public void Dispose()
{
ParkSharkDbContext?.Dispose();
Mapper = null;
}
