/// <summary>
/// Setup for Nunit Tests
/// </summary>
protected override void OnSetup()
{
mockILoggingHelper = CreateMock <ILoggingHelper>();
List <OSRoadLink> oSRoadLink = new List <OSRoadLink>()
{
new OSRoadLink()
{
TOID = "123", RouteHierarchy = "1"
}
};
// Setup for OSRoadLink.
var mockOSRoadLinkEnumerable = new DbAsyncEnumerable <OSRoadLink>(oSRoadLink);
var mockOSRoadLinkDataService = MockDbSet(oSRoadLink);
mockOSRoadLinkDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockOSRoadLinkEnumerable.AsQueryable().Provider);
mockOSRoadLinkDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockOSRoadLinkEnumerable.AsQueryable().Expression);
mockOSRoadLinkDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockOSRoadLinkEnumerable.AsQueryable().ElementType);
mockOSRoadLinkDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <OSRoadLink>)mockOSRoadLinkEnumerable).GetAsyncEnumerator());
mockNetworkDBContext = CreateMock <NetworkDBContext>();
mockNetworkDBContext.Setup(x => x.Set <OSRoadLink>()).Returns(mockOSRoadLinkDataService.Object);
mockNetworkDBContext.Setup(x => x.OSRoadLinks).Returns(mockOSRoadLinkDataService.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <NetworkDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockNetworkDBContext.Object);
// Setup for IRMTraceManager.
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new OSRoadLinkDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
loggingHelperMock = CreateMock <ILoggingHelper>();
List <OSRoadLink> oSRoadLink = new List <OSRoadLink>()
{
new OSRoadLink()
{
TOID = "123", RouteHierarchy = "1"
}
};
var mockOSRoadLinkEnumerable = new DbAsyncEnumerable <OSRoadLink>(oSRoadLink);
var mockOSRoadLinkDataService = MockDbSet(oSRoadLink);
mockOSRoadLinkDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockOSRoadLinkEnumerable.AsQueryable().Provider);
mockOSRoadLinkDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockOSRoadLinkEnumerable.AsQueryable().Expression);
mockOSRoadLinkDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockOSRoadLinkEnumerable.AsQueryable().ElementType);
mockOSRoadLinkDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <OSRoadLink>)mockOSRoadLinkEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <OSRoadLink>()).Returns(mockOSRoadLinkDataService.Object);
mockRMDBContext.Setup(x => x.OSRoadLinks).Returns(mockOSRoadLinkDataService.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new OSRoadLinkDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
/// <summary>
/// setup for nunit tests
/// </summary>
protected override void OnSetup()
{
// Data Setup
List <Scenario> scenarioList = new List <Scenario>()
{
new Scenario()
{
LocationID = locationID,
ID = new Guid("2534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <ScenarioStatus> scenarioStatusList = new List <ScenarioStatus>()
{
new ScenarioStatus()
{
ScenarioStatusGUID = scenarioStatusGUID,
ScenarioID = new Guid("2534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
mockUnitManagerDbContext = CreateMock <UnitManagerDbContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for Scenario
var mockAsynEnumerable1 = new DbAsyncEnumerable <Scenario>(scenarioList);
var mockScenario = MockDbSet(scenarioList);
mockScenario.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockScenario.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockScenario.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockScenario.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Scenario>)mockAsynEnumerable1).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <Scenario>()).Returns(mockScenario.Object);
mockUnitManagerDbContext.Setup(x => x.Scenarios).Returns(mockScenario.Object);
mockUnitManagerDbContext.Setup(c => c.Scenarios.AsNoTracking()).Returns(mockScenario.Object);
// Setup for PostalAddress
var mockAsynEnumerable2 = new DbAsyncEnumerable <ScenarioStatus>(scenarioStatusList);
var mockScenarioStatus = MockDbSet(scenarioStatusList);
mockScenarioStatus.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockScenarioStatus.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockScenarioStatus.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockScenarioStatus.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <ScenarioStatus>)mockAsynEnumerable2).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <ScenarioStatus>()).Returns(mockScenarioStatus.Object);
mockUnitManagerDbContext.Setup(x => x.ScenarioStatus).Returns(mockScenarioStatus.Object);
mockUnitManagerDbContext.Setup(c => c.ScenarioStatus.AsNoTracking()).Returns(mockScenarioStatus.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <UnitManagerDbContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockUnitManagerDbContext.Object);
testCandidate = new ScenarioDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object);
}
/// <summary>
/// Setup for Nunit Tests
/// </summary>
protected override void OnSetup()
{
// Data Setup
List <PostcodeHierarchy> postcodeHierarchyList = new List <PostcodeHierarchy>()
{
new PostcodeHierarchy()
{
PostcodeTypeGUID = postcodeTypeGUID,
ParentPostcode = "111",
Postcode = "123"
}
};
List <PostalAddress> postalAddressList = new List <PostalAddress>()
{
new PostalAddress()
{
UDPRN = 123,
Postcode = "123"
}
};
mockUnitManagerDbContext = CreateMock <UnitManagerDbContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for PostcodeHierarchy
var mockAsynEnumerable1 = new DbAsyncEnumerable <PostcodeHierarchy>(postcodeHierarchyList);
var mockPostcodeHierarchy = MockDbSet(postcodeHierarchyList);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostcodeHierarchy>)mockAsynEnumerable1).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostcodeHierarchy>()).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.PostcodeHierarchies).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(c => c.PostcodeHierarchies.AsNoTracking()).Returns(mockPostcodeHierarchy.Object);
// Setup for PostalAddress
var mockAsynEnumerable2 = new DbAsyncEnumerable <PostalAddress>(postalAddressList);
var mockPostalAddress = MockDbSet(postalAddressList);
mockPostalAddress.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockPostalAddress.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockPostalAddress.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockPostalAddress.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddress>)mockAsynEnumerable2).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostalAddress>()).Returns(mockPostalAddress.Object);
mockUnitManagerDbContext.Setup(x => x.PostalAddresses).Returns(mockPostalAddress.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <UnitManagerDbContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockUnitManagerDbContext.Object);
testCandidate = new PostcodeSectorDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object);
}
protected override void OnSetup()
{
loggingHelperMock = CreateMock <ILoggingHelper>();
var referenceDataCategory = new List <ReferenceDataCategory>()
{
new ReferenceDataCategory()
{
ID = Guid.NewGuid(),
CategoryName = "Postal Address Type",
ReferenceDatas = new List <ReferenceData>()
{
new ReferenceData()
{
ReferenceDataName = "PAF",
DataDescription = "PAF",
ReferenceDataCategory_GUID = new Guid("4A6F8F72-AE47-4EC4-8FCB-EFCFEB900ADD"),
ID = new Guid("4A6F8F72-AE47-4EC4-8FCB-EFCFEB900ADD"),
ReferenceDataValue = "PAF"
},
new ReferenceData()
{
ReferenceDataName = "PAF",
DataDescription = "PAF",
ReferenceDataCategory_GUID = new Guid("4A6F8F73-AE47-4EC4-8FCB-EFCFEB900ADD"),
ID = new Guid("4A6F8F73-AE47-4EC4-8FCB-EFCFEB900ADD"),
ReferenceDataValue = "NYB"
}
}
}
};
var mockAsynEnumerable = new DbAsyncEnumerable <ReferenceDataCategory>(referenceDataCategory);
var mockReferenceDataCategoryDBSet = MockDbSet(referenceDataCategory);
mockReferenceDataCategoryDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockReferenceDataCategoryDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockReferenceDataCategoryDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockReferenceDataCategoryDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <ReferenceDataCategory>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <ReferenceDataCategory>()).Returns(mockReferenceDataCategoryDBSet.Object);
mockRMDBContext.Setup(x => x.ReferenceDataCategories).Returns(mockReferenceDataCategoryDBSet.Object);
mockRMDBContext.Setup(c => c.ReferenceDataCategories.AsNoTracking()).Returns(mockReferenceDataCategoryDBSet.Object);
mockReferenceDataCategoryDBSet.Setup(x => x.Include(It.IsAny <string>())).Returns(mockReferenceDataCategoryDBSet.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new ReferenceDataCategoryDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
/// <summary>
/// Setup for Nunit Tests.
/// </summary>
protected override void OnSetup()
{
string sbLocationXY = string.Format("POINT({0} {1})", "1234", "4567");
addressLocationDataDTO = new AddressLocationDataDTO
{
ID = new Guid(),
UDPRN = 158642,
LocationXY = DbGeometry.FromText(sbLocationXY.ToString(), 27700),
Lattitude = 51.64m,
Longitude = -0.71m
};
var addressLocation = new List <AddressLocation>
{
new AddressLocation()
{
ID = new Guid(),
UDPRN = 158642,
LocationXY = DbGeometry.FromText(sbLocationXY.ToString(), 27700),
Lattitude = 51.64m,
Longitude = -0.71m
}
};
var mockAsynEnumerable = new DbAsyncEnumerable <AddressLocation>(addressLocation);
var mockAddressLocationDataService = MockDbSet(addressLocation);
mockAddressLocationDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockAddressLocationDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockAddressLocationDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockAddressLocationDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <AddressLocation>)mockAsynEnumerable).GetAsyncEnumerator());
mockAddressLocationDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAddressLocationDataService.Object);
mockAddressLocationDataService.Setup(x => x.AsNoTracking()).Returns(mockAddressLocationDataService.Object);
mockAddressLocationDBContext = CreateMock <AddressLocationDBContext>();
mockAddressLocationDBContext.Setup(x => x.Set <AddressLocation>()).Returns(mockAddressLocationDataService.Object);
mockAddressLocationDBContext.Setup(x => x.AddressLocations).Returns(mockAddressLocationDataService.Object);
mockLoggingHelper = CreateMock <ILoggingHelper>();
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockAddressLocationDBFactory = CreateMock <IDatabaseFactory <AddressLocationDBContext> >();
mockAddressLocationDBFactory.Setup(x => x.Get()).Returns(mockAddressLocationDBContext.Object);
mockAddressLocationDBContext.Setup(n => n.SaveChangesAsync()).ReturnsAsync(1);
testCandidate = new AddressLocationDataService(mockAddressLocationDBFactory.Object, mockLoggingHelper.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
loggingHelperMock = CreateMock <ILoggingHelper>();
var deliveryScenario = new List <Scenario>()
{
new Scenario()
{
ScenarioName = "Worthing Delivery Office - Baseline weekday", Unit_GUID = System.Guid.Parse("B51AA229-C984-4CA6-9C12-510187B81050"), OperationalState_GUID = System.Guid.Parse("9C1E56D7-5397-4984-9CF0-CD9EE7093C88")
},
new Scenario()
{
ScenarioName = "High Wycombe North Delivery Office - Baseline week", Unit_GUID = System.Guid.Parse("B51AA229-C984-4CA6-9C12-510187B81050"), OperationalState_GUID = System.Guid.Parse("9C1E56D7-5397-4984-9CF0-CD9EE7093C88")
},
new Scenario()
{
ScenarioName = "High Wycombe South Delivery Office - Baseline week", Unit_GUID = System.Guid.Parse("B51AA229-C984-4CA6-9C12-510187B81050"), OperationalState_GUID = System.Guid.Parse("9C1E56D7-5397-4984-9CF0-CD9EE7093C88")
}
};
var mockAsynEnumerable = new DbAsyncEnumerable <Scenario>(deliveryScenario);
var mockDeliveryScenarioDBSet = MockDbSet(deliveryScenario);
mockDeliveryScenarioDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockDeliveryScenarioDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockDeliveryScenarioDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockDeliveryScenarioDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Scenario>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <Scenario>()).Returns(mockDeliveryScenarioDBSet.Object);
mockRMDBContext.Setup(x => x.Scenarios).Returns(mockDeliveryScenarioDBSet.Object);
mockRMDBContext.Setup(c => c.Scenarios.AsNoTracking()).Returns(mockDeliveryScenarioDBSet.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new ScenarioDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
public async Task Test_GetPostcodes_NegativeScenario()
{
// Setup for PostcodeHierarchy with mocked AsNoTracking()
var mockAsynEnumerable4 = new DbAsyncEnumerable <PostcodeHierarchy>(postcodeHierarchyList);
var mockPostcodeHierarchy = MockDbSet(postcodeHierarchyList);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
mockPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostcodeHierarchy>)mockAsynEnumerable4).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostcodeHierarchy>()).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.PostcodeHierarchies).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(c => c.PostcodeHierarchies.AsNoTracking()).Returns(mockPostcodeHierarchy.Object);
var result = await testCandidate.GetPostcodes(new List <Guid>() { Guid.Empty }, postcodeTypeGUID);
Assert.IsNotNull(result);
Assert.AreEqual(result.ToList().Count, 0);
}
/// <summary>
/// Tests setup for methods and data
/// </summary>
protected override void OnSetup()
{
mockLoggingHelper = CreateMock <ILoggingHelper>();
// Data Setup
userUnitInfoDataDTOList = new List <UserUnitInfoDataDTO>()
{
new UserUnitInfoDataDTO()
{
UserName = "******",
LocationId = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A")
},
new UserUnitInfoDataDTO()
{
UserName = "******",
LocationId = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A")
}
};
List <AccessFunction> accessFunctionList = new List <AccessFunction>()
{
new AccessFunction()
{
RoleName = "manager",
LocationID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
UserName = "******",
FunctionName = "PrintMap",
ActionName = "Print",
UserId = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
},
new AccessFunction()
{
RoleName = "collection hub",
LocationID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
UserName = "******",
FunctionName = "accesslink",
ActionName = "create",
UserId = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
},
new AccessFunction()
{
RoleName = "delivery unit",
LocationID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
UserName = "******",
FunctionName = "delivery point",
ActionName = "create",
UserId = new Guid("6B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
}
};
UserRoleLocation userRoleLocation = new UserRoleLocation()
{
LocationID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
UserID = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED")
};
User user = new User()
{
ID = new Guid("5B9C7207-3D20-E711-9F8C-28D244AEF9ED"),
UserName = "******"
};
LocationReferenceData locationReferenceData = new LocationReferenceData()
{
ReferenceDataID = new Guid("AFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
LocationID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A")
};
ReferenceData referenceData = new ReferenceData()
{
ID = new Guid("AFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
ReferenceDataValue = "Type1"
};
PostalAddressIdentifier postalAddressIdentifier = new PostalAddressIdentifier()
{
ID = new Guid("FFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
IdentifierTypeGUID = new Guid("AFD741D9-5BBE-4D7F-9C3B-79D3588DC98A"),
Name = "Unit1"
};
//Setup for UserRoleLocation
mockRMDBContext = CreateMock <ActionDBContext>();
var mockAsynEnumerable1 = new DbAsyncEnumerable <UserRoleLocation>(new List <UserRoleLocation>()
{
userRoleLocation
});
var mockUserRoleLocation = MockDbSet(new List <UserRoleLocation>()
{
userRoleLocation
});
mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockUserRoleLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <UserRoleLocation>)mockAsynEnumerable1).GetAsyncEnumerator());
mockUserRoleLocation.Setup(x => x.AsNoTracking()).Returns(mockUserRoleLocation.Object);
mockRMDBContext.Setup(x => x.Set <UserRoleLocation>()).Returns(mockUserRoleLocation.Object);
mockRMDBContext.Setup(x => x.UserRoleLocations).Returns(mockUserRoleLocation.Object);
mockUserRoleLocation.Setup(x => x.Include(It.IsAny <string>())).Returns(mockUserRoleLocation.Object);
//Setup for User
var mockAsynEnumerable2 = new DbAsyncEnumerable <User>(new List <User>()
{
user
});
var mockUser = MockDbSet(new List <User>()
{
user
});
mockUser.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockUser.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockUser.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockUser.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <User>)mockAsynEnumerable2).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <User>()).Returns(mockUser.Object);
mockRMDBContext.Setup(x => x.Users).Returns(mockUser.Object);
mockUser.Setup(x => x.Include(It.IsAny <string>())).Returns(mockUser.Object);
//Setup for LocationReferenceData
var mockAsynEnumerable3 = new DbAsyncEnumerable <LocationReferenceData>(new List <LocationReferenceData>()
{
locationReferenceData
});
var mockLocationReferenceData = MockDbSet(new List <LocationReferenceData>()
{
locationReferenceData
});
mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockLocationReferenceData.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationReferenceData>)mockAsynEnumerable3).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <LocationReferenceData>()).Returns(mockLocationReferenceData.Object);
mockRMDBContext.Setup(x => x.LocationReferenceDatas).Returns(mockLocationReferenceData.Object);
mockLocationReferenceData.Setup(x => x.Include(It.IsAny <string>())).Returns(mockLocationReferenceData.Object);
//Setup for LocationReferenceData
var mockAsynEnumerable4 = new DbAsyncEnumerable <ReferenceData>(new List <ReferenceData>()
{
referenceData
});
var mockReferenceData = MockDbSet(new List <ReferenceData>()
{
referenceData
});
mockReferenceData.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
mockReferenceData.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
mockReferenceData.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
mockReferenceData.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <ReferenceData>)mockAsynEnumerable4).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <ReferenceData>()).Returns(mockReferenceData.Object);
mockRMDBContext.Setup(x => x.ReferenceDatas).Returns(mockReferenceData.Object);
mockReferenceData.Setup(x => x.Include(It.IsAny <string>())).Returns(mockReferenceData.Object);
//Setup for PostalAddressIdentifier
var mockAsynEnumerable5 = new DbAsyncEnumerable <PostalAddressIdentifier>(new List <PostalAddressIdentifier>()
{
postalAddressIdentifier
});
var mockPostalAddressIdentifier = MockDbSet(new List <PostalAddressIdentifier>()
{
postalAddressIdentifier
});
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable5.AsQueryable().Provider);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable5.AsQueryable().Expression);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable5.AsQueryable().ElementType);
mockPostalAddressIdentifier.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddressIdentifier>)mockAsynEnumerable5).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <PostalAddressIdentifier>()).Returns(mockPostalAddressIdentifier.Object);
mockRMDBContext.Setup(x => x.PostalAddressIdentifiers).Returns(mockPostalAddressIdentifier.Object);
mockPostalAddressIdentifier.Setup(x => x.Include(It.IsAny <string>())).Returns(mockPostalAddressIdentifier.Object);
//Setup for AccessFunction
var mockAsynEnumerable6 = new DbAsyncEnumerable <AccessFunction>(accessFunctionList);
var mockAccessFunction = MockDbSet(accessFunctionList);
mockAccessFunction.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable6.AsQueryable().Provider);
mockAccessFunction.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable6.AsQueryable().Expression);
mockAccessFunction.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable6.AsQueryable().ElementType);
mockAccessFunction.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <AccessFunction>)mockAsynEnumerable6).GetAsyncEnumerator());
mockAccessFunction.Setup(x => x.AsNoTracking()).Returns(mockAccessFunction.Object);
mockRMDBContext.Setup(x => x.Set <AccessFunction>()).Returns(mockAccessFunction.Object);
mockRMDBContext.Setup(x => x.AccessFunctions).Returns(mockAccessFunction.Object);
mockAccessFunction.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessFunction.Object);
//Setup for Logging
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <ActionDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
testCandidate = new ActionManagerDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
loggingHelperMock = CreateMock <ILoggingHelper>();
var unitPostcodeSectors = new List <UnitPostcodeSector>()
{
new UnitPostcodeSector()
{
Unit_GUID = new Guid("8534AA41-391F-4579-A18D-D7EDF5B5F918"),
PostcodeSector_GUID = new Guid("0C65F088-874F-40FB-A753-8F29C371821F")
}
};
var postcodeSectorSingle1 = new PostcodeSector
{
ID = new Guid("0C65F088-874F-40FB-A753-8F29C371821F"),
UnitPostcodeSectors = unitPostcodeSectors
};
var postcodeSector = new List <PostcodeSector>()
{
new PostcodeSector
{
ID = new Guid("0C65F088-874F-40FB-A753-8F29C371821F"),
UnitPostcodeSectors = unitPostcodeSectors
}
};
var postcode = new List <Postcode>()
{
new Postcode()
{
PostcodeUnit = "search12",
PostcodeSector = postcodeSectorSingle1,
SectorGUID = new Guid("0C65F088-874F-40FB-A753-8F29C371821F"),
InwardCode = "1",
OutwardCode = "2",
Sector = "test1"
}
};
var mockAsynEnumerable = new DbAsyncEnumerable <Postcode>(postcode);
var mockPostCodeDataService = MockDbSet(postcode);
mockPostCodeDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockPostCodeDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockPostCodeDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockPostCodeDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Postcode>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <Postcode>()).Returns(mockPostCodeDataService.Object);
mockRMDBContext.Setup(x => x.Postcodes).Returns(mockPostCodeDataService.Object);
mockRMDBContext.Setup(c => c.Postcodes.AsNoTracking()).Returns(mockPostCodeDataService.Object);
var mockAsynEnumerable2 = new DbAsyncEnumerable <UnitPostcodeSector>(unitPostcodeSectors);
var mockPostCodeDataService2 = MockDbSet(unitPostcodeSectors);
mockPostCodeDataService2.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockPostCodeDataService2.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockPostCodeDataService2.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockPostCodeDataService2.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <UnitPostcodeSector>)mockAsynEnumerable2).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <UnitPostcodeSector>()).Returns(mockPostCodeDataService2.Object);
mockRMDBContext.Setup(x => x.UnitPostcodeSectors).Returns(mockPostCodeDataService2.Object);
mockRMDBContext.Setup(c => c.UnitPostcodeSectors.AsNoTracking()).Returns(mockPostCodeDataService2.Object);
var mockAsynEnumerable3 = new DbAsyncEnumerable <PostcodeSector>(postcodeSector);
var mockPostCodeDataService3 = MockDbSet(postcodeSector);
mockPostCodeDataService3.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockPostCodeDataService3.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockPostCodeDataService3.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockPostCodeDataService3.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostcodeSector>)mockAsynEnumerable3).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <PostcodeSector>()).Returns(mockPostCodeDataService3.Object);
mockRMDBContext.Setup(x => x.PostcodeSectors).Returns(mockPostCodeDataService3.Object);
mockRMDBContext.Setup(c => c.PostcodeSectors.AsNoTracking()).Returns(mockPostCodeDataService3.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new PostCodeDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
protected override void OnSetup()
{
var scenarios = new List <Scenario>()
{
new Scenario()
{
ID = new Guid("ED148EE4-46A7-4EA5-B0C9-1654085159D0"), ScenarioName = "High Wycome Collection Office - Baseline week", LocationID = new Guid("F08AAD61-B83F-463D-95D6-F0583F24644F")
}
};
var scenarioRoutes = new List <ScenarioRoute>()
{
new ScenarioRoute()
{
ScenarioID = new Guid("ED148EE4-46A7-4EA5-B0C9-1654085159D0"), RouteID = new Guid("F87F67EC-FAFA-4156-9C3D-85722719CE12")
}
};
var routes = new List <Route>()
{
new Route()
{
ID = new Guid("F87F67EC-FAFA-4156-9C3D-85722719CE12"), SpanTimeMinute = 120, RouteName = "1415 BROADWATER ST EAST", RouteNumber = "415", UnSequencedBlockID = new Guid("61154482-8493-4130-A5E1-64E86C9757BC"), RouteMethodTypeGUID = new Guid("E1D25B7F-561B-E711-9F8C-28D244AEF9ED")
}
};
var routeActivites = new List <RouteActivity>()
{
new RouteActivity()
{
ID = new Guid("F21BD083-9FB5-4420-86EF-7205A5075870"), RouteID = new Guid("F87F67EC-FAFA-4156-9C3D-85722719CE12"), ActivityTypeGUID = new Guid("7803247C-F866-E711-80ED-000D3A22173B"), ResourceGUID = new Guid("E1D25B7F-561B-E711-9F8C-28D244AEF9ED"), LocationID = new Guid("F08AAD61-B83F-463D-95D6-F0583F24644F")
}
};
var blockSequences = new List <BlockSequence>()
{
new BlockSequence()
{
ID = new Guid("4FEB3A4A-A25E-42AF-AAD9-6B0BD51C9A1D"), BlockID = new Guid("61154482-8493-4130-A5E1-64E86C9757BC"), LocationID = new Guid("F08AAD61-B83F-463D-95D6-F0583F24644F")
}
};
var postcodes = new List <Postcode>()
{
new Postcode()
{
ID = new Guid("E436B42D-A2C1-4E15-9E84-EB48A4474608"), PrimaryRouteGUID = new Guid("02B18F5E-1C1A-410F-AA51-C7CA0EC7216C"), PostcodeUnit = "EC4P 4GY"
}
};
var deliveryPoints = new List <DeliveryPoint>()
{
new DeliveryPoint()
{
ID = new Guid("F08AAD61-B83F-463D-95D6-F0583F24644F"), DeliveryPointUseIndicatorGUID = new Guid("178EDCAD-9431-E711-83EC-28D244AEF9ED"), MultipleOccupancyCount = 10, PostalAddressID = new Guid("7A5BF574-9ACA-4B8E-809D-00062A033342"),
PostalAddress = new PostalAddress()
{
ID = new Guid("7A5BF574-9ACA-4B8E-809D-00062A033342"), Thoroughfare = "Steyne Gardens", BuildingNumber = 10, SubBuildingName = "Apartment 33", BuildingName = "Warnes", Postcode = "EC4P 4GY"
}
}
};
var postalAddresses = new List <PostalAddress>()
{
new PostalAddress()
{
ID = new Guid("7A5BF574-9ACA-4B8E-809D-00062A033342"), Thoroughfare = "Steyne Gardens", BuildingNumber = 10, SubBuildingName = "Apartment 33", BuildingName = "Warnes", Postcode = "EC4P 4GY"
}
};
mockRouteDBContext = CreateMock <RouteDBContext>();
mockLoggingHelper = CreateMock <ILoggingHelper>();
mockConfigHelper = CreateMock <IConfigurationHelper>();
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockConfigHelper.Setup(x => x.ReadAppSettingsConfigurationValues(It.IsAny <string>())).Returns("5");
var mockAsyncScenarios = new DbAsyncEnumerable <Scenario>(scenarios);
var mockScenariosDBSet = MockDbSet(scenarios);
mockScenariosDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsyncScenarios.AsQueryable().Provider);
mockScenariosDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsyncScenarios.AsQueryable().Expression);
mockScenariosDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsyncScenarios.AsQueryable().ElementType);
mockScenariosDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Scenario>)mockAsyncScenarios).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <Scenario>()).Returns(mockScenariosDBSet.Object);
mockRouteDBContext.Setup(x => x.Scenarios).Returns(mockScenariosDBSet.Object);
mockRouteDBContext.Setup(c => c.Scenarios.AsNoTracking()).Returns(mockScenariosDBSet.Object);
var mockAsynScenarioRoutes = new DbAsyncEnumerable <ScenarioRoute>(scenarioRoutes);
var mockScenarioRoutesDBSet = MockDbSet(scenarioRoutes);
mockScenarioRoutesDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynScenarioRoutes.AsQueryable().Provider);
mockScenarioRoutesDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynScenarioRoutes.AsQueryable().Expression);
mockScenarioRoutesDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynScenarioRoutes.AsQueryable().ElementType);
mockScenarioRoutesDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <ScenarioRoute>)mockAsynScenarioRoutes).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <ScenarioRoute>()).Returns(mockScenarioRoutesDBSet.Object);
mockRouteDBContext.Setup(x => x.ScenarioRoutes).Returns(mockScenarioRoutesDBSet.Object);
mockRouteDBContext.Setup(c => c.ScenarioRoutes.AsNoTracking()).Returns(mockScenarioRoutesDBSet.Object);
var mockAsynRoutes = new DbAsyncEnumerable <Route>(routes);
var mockRoutesDBSet = MockDbSet(routes);
mockRoutesDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynRoutes.AsQueryable().Provider);
mockRoutesDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynRoutes.AsQueryable().Expression);
mockRoutesDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynRoutes.AsQueryable().ElementType);
mockRoutesDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Route>)mockAsynRoutes).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <Route>()).Returns(mockRoutesDBSet.Object);
mockRouteDBContext.Setup(x => x.Routes).Returns(mockRoutesDBSet.Object);
mockRouteDBContext.Setup(c => c.Routes.AsNoTracking()).Returns(mockRoutesDBSet.Object);
var mockAsynRouteActivites = new DbAsyncEnumerable <RouteActivity>(routeActivites);
var mockRouteAcitivityDBSet = MockDbSet(routeActivites);
mockRouteAcitivityDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynRouteActivites.AsQueryable().Provider);
mockRouteAcitivityDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynRouteActivites.AsQueryable().Expression);
mockRouteAcitivityDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynRouteActivites.AsQueryable().ElementType);
mockRouteAcitivityDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <RouteActivity>)mockAsynRouteActivites).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <RouteActivity>()).Returns(mockRouteAcitivityDBSet.Object);
mockRouteDBContext.Setup(x => x.RouteActivities).Returns(mockRouteAcitivityDBSet.Object);
mockRouteDBContext.Setup(c => c.RouteActivities.AsNoTracking()).Returns(mockRouteAcitivityDBSet.Object);
var mockAsynBlockSequences = new DbAsyncEnumerable <BlockSequence>(blockSequences);
var mockBlockSequencesDBSet = MockDbSet(blockSequences);
mockBlockSequencesDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynBlockSequences.AsQueryable().Provider);
mockBlockSequencesDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynBlockSequences.AsQueryable().Expression);
mockBlockSequencesDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynBlockSequences.AsQueryable().ElementType);
mockBlockSequencesDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <BlockSequence>)mockAsynBlockSequences).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <BlockSequence>()).Returns(mockBlockSequencesDBSet.Object);
mockRouteDBContext.Setup(x => x.BlockSequences).Returns(mockBlockSequencesDBSet.Object);
mockRouteDBContext.Setup(c => c.BlockSequences.AsNoTracking()).Returns(mockBlockSequencesDBSet.Object);
var mockAsynPostcodes = new DbAsyncEnumerable <Postcode>(postcodes);
var mockPoscodesDBSet = MockDbSet(postcodes);
mockPoscodesDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynPostcodes.AsQueryable().Provider);
mockPoscodesDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynPostcodes.AsQueryable().Expression);
mockPoscodesDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynPostcodes.AsQueryable().ElementType);
mockPoscodesDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Postcode>)mockAsynPostcodes).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <Postcode>()).Returns(mockPoscodesDBSet.Object);
mockRouteDBContext.Setup(x => x.Postcodes).Returns(mockPoscodesDBSet.Object);
mockRouteDBContext.Setup(c => c.Postcodes.AsNoTracking()).Returns(mockPoscodesDBSet.Object);
var mockAsyndeliveryPoints = new DbAsyncEnumerable <DeliveryPoint>(deliveryPoints);
var mockdeliveryPointsDBSet = MockDbSet(deliveryPoints);
mockdeliveryPointsDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsyndeliveryPoints.AsQueryable().Provider);
mockdeliveryPointsDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsyndeliveryPoints.AsQueryable().Expression);
mockdeliveryPointsDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsyndeliveryPoints.AsQueryable().ElementType);
mockdeliveryPointsDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPoint>)mockAsyndeliveryPoints).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <DeliveryPoint>()).Returns(mockdeliveryPointsDBSet.Object);
mockRouteDBContext.Setup(x => x.DeliveryPoints).Returns(mockdeliveryPointsDBSet.Object);
mockdeliveryPointsDBSet.Setup(x => x.Include(It.IsAny <string>())).Returns(mockdeliveryPointsDBSet.Object);
mockdeliveryPointsDBSet.Setup(c => c.AsNoTracking()).Returns(mockdeliveryPointsDBSet.Object);
var mockAsyncPostalAddresses = new DbAsyncEnumerable <PostalAddress>(postalAddresses);
var mockPostalAddressesDBSet = MockDbSet(postalAddresses);
mockPostalAddressesDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsyncPostalAddresses.AsQueryable().Provider);
mockPostalAddressesDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsyncPostalAddresses.AsQueryable().Expression);
mockPostalAddressesDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsyncPostalAddresses.AsQueryable().ElementType);
mockPostalAddressesDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddress>)mockAsyncPostalAddresses).GetAsyncEnumerator());
mockRouteDBContext.Setup(x => x.Set <PostalAddress>()).Returns(mockPostalAddressesDBSet.Object);
mockRouteDBContext.Setup(x => x.PostalAddresses).Returns(mockPostalAddressesDBSet.Object);
mockRouteDBContext.Setup(c => c.PostalAddresses.AsNoTracking()).Returns(mockPostalAddressesDBSet.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RouteDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRouteDBContext.Object);
testCandidate = new DeliveryRouteDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object, mockConfigHelper.Object);
}
protected override void OnSetup()
{
currentUserUnitType = "Delivery Office";
var deliveryPoint = new List <DeliveryPoint>()
{
new DeliveryPoint()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
PostalAddressID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA"),
DeliveryPointUseIndicatorGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A14"),
RowVersion = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 },
PostalAddress = new PostalAddress()
{
BuildingName = "road bldg2",
BuildingNumber = 1,
SubBuildingName = "road subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "road ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "road PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA"),
},
DeliveryPointStatus = new List <DeliveryPointStatus>()
{
new DeliveryPointStatus()
{
LocationID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
},
NetworkNode = new NetworkNode()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Location = new Location()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700)
}
},
}
};
var location = new List <Location>()
{
new Location()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700),
RowCreateDateTime = DateTime.Now,
NetworkNode = new NetworkNode()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
DeliveryPoint = new DeliveryPoint()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
PostalAddressID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA"),
DeliveryPointUseIndicatorGUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A14")
}
}
//,
//LocationOfferings = new List<LocationOffering>() {
// new LocationOffering
// {
// ID= new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
// }
//}
}
};
var networkNode = new List <NetworkNode>()
{
new NetworkNode()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Location = new Location()
{
Shape = DbGeometry.PointFromText("POINT (488938 197021)", 27700)
}
}
};
var postalAddress = new List <PostalAddress>
{
new PostalAddress()
{
BuildingName = "road bldg2",
BuildingNumber = 1,
SubBuildingName = "road subbldg1",
OrganisationName = "org",
DepartmentName = "department",
Thoroughfare = "road ThoroughFare1",
DependentThoroughfare = "DependentThoroughFare1",
Postcode = "road PostcodeNew",
PostTown = "PostTown",
POBoxNumber = "POBoxNumber",
UDPRN = 12345,
PostcodeType = "xyz",
SmallUserOrganisationIndicator = "indicator",
DeliveryPointSuffix = "DeliveryPointSuffix",
AddressType_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A19"),
ID = new Guid("619AF1F3-AE0C-4157-9BDE-A7528C1482BA")
},
};
var deliveryPointStatus = new List <DeliveryPointStatus>()
{
new DeliveryPointStatus()
{
LocationID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
};
var locationOfferings = new List <LocationOffering>()
{
new LocationOffering
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13"),
Offering = new Offering()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
}
};
mockLoggingHelper = CreateMock <ILoggingHelper>();
mockRMDBContext = CreateMock <DeliveryPointDBContext>();
// setup for Deliverypoint
var mockAsynEnumerable = new DbAsyncEnumerable <DeliveryPoint>(deliveryPoint);
var mockDeliveryPointDataService = MockDbSet(deliveryPoint);
mockDeliveryPointDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockDeliveryPointDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockDeliveryPointDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockDeliveryPointDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPoint>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryPoint>()).Returns(mockDeliveryPointDataService.Object);
mockRMDBContext.Setup(x => x.DeliveryPoints).Returns(mockDeliveryPointDataService.Object);
mockDeliveryPointDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockDeliveryPointDataService.Object);
mockDeliveryPointDataService.Setup(x => x.AsNoTracking()).Returns(mockDeliveryPointDataService.Object);
// setup for location
var mockAsynEnumerable1 = new DbAsyncEnumerable <Location>(location);
var mockLocation = MockDbSet(location);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable1).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockRMDBContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockLocation.Setup(x => x.Include(It.IsAny <string>())).Returns(mockLocation.Object);
mockLocation.Setup(x => x.AsNoTracking()).Returns(mockLocation.Object);
// setup for networknode
var mockAsynNetworkNode = new DbAsyncEnumerable <NetworkNode>(networkNode);
var mocknetworkNode = MockDbSet(networkNode);
mocknetworkNode.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynNetworkNode.AsQueryable().Provider);
mocknetworkNode.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynNetworkNode.AsQueryable().Expression);
mocknetworkNode.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynNetworkNode.AsQueryable().ElementType);
mocknetworkNode.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <NetworkNode>)mockAsynNetworkNode).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <NetworkNode>()).Returns(mocknetworkNode.Object);
mockRMDBContext.Setup(x => x.NetworkNodes).Returns(mocknetworkNode.Object);
mocknetworkNode.Setup(x => x.Include(It.IsAny <string>())).Returns(mocknetworkNode.Object);
mocknetworkNode.Setup(x => x.AsNoTracking()).Returns(mocknetworkNode.Object);
// setup for PostalAdress
var mockAsynPostalAdress = new DbAsyncEnumerable <PostalAddress>(postalAddress);
var mocknpostalAddresse = MockDbSet(postalAddress);
mocknpostalAddresse.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynPostalAdress.AsQueryable().Provider);
mocknpostalAddresse.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynPostalAdress.AsQueryable().Expression);
mocknpostalAddresse.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynPostalAdress.AsQueryable().ElementType);
mocknpostalAddresse.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddress>)mockAsynPostalAdress).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <PostalAddress>()).Returns(mocknpostalAddresse.Object);
mockRMDBContext.Setup(x => x.PostalAddresses).Returns(mocknpostalAddresse.Object);
mocknpostalAddresse.Setup(x => x.Include(It.IsAny <string>())).Returns(mocknpostalAddresse.Object);
mocknpostalAddresse.Setup(x => x.AsNoTracking()).Returns(mocknpostalAddresse.Object);
// setup for delivery point status
var mockAsyndpStatus = new DbAsyncEnumerable <DeliveryPointStatus>(deliveryPointStatus);
var mockdpStatus = MockDbSet(deliveryPointStatus);
mockdpStatus.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsyndpStatus.AsQueryable().Provider);
mockdpStatus.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsyndpStatus.AsQueryable().Expression);
mockdpStatus.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsyndpStatus.AsQueryable().ElementType);
mockdpStatus.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPointStatus>)mockAsyndpStatus).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryPointStatus>()).Returns(mockdpStatus.Object);
mockRMDBContext.Setup(x => x.DeliveryPointStatus).Returns(mockdpStatus.Object);
mockdpStatus.Setup(x => x.Include(It.IsAny <string>())).Returns(mockdpStatus.Object);
mockdpStatus.Setup(x => x.AsNoTracking()).Returns(mockdpStatus.Object);
// setup for location offerings
var mockAsynlocOfferings = new DbAsyncEnumerable <LocationOffering>(locationOfferings);
var mocklocOfferings = MockDbSet(locationOfferings);
mocklocOfferings.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynlocOfferings.AsQueryable().Provider);
mocklocOfferings.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynlocOfferings.AsQueryable().Expression);
mocklocOfferings.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynlocOfferings.AsQueryable().ElementType);
mocklocOfferings.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationOffering>)mockAsynlocOfferings).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <LocationOffering>()).Returns(mocklocOfferings.Object);
mockRMDBContext.Setup(x => x.LocationOfferings).Returns(mocklocOfferings.Object);
mocklocOfferings.Setup(x => x.Include(It.IsAny <string>())).Returns(mocklocOfferings.Object);
mocklocOfferings.Setup(x => x.AsNoTracking()).Returns(mocklocOfferings.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
// mockConfigurationHelper = new Mock<IConfigurationHelper>();
mockDatabaseFactory = CreateMock <IDatabaseFactory <DeliveryPointDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
mockRMDBContext.Setup(n => n.SaveChangesAsync()).ReturnsAsync(1);
testCandidate = new DeliveryPointsDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
/// <summary>
/// setup for nunit tests
/// </summary>
protected override void OnSetup()
{
// Data Setup
List <PostalAddressIdentifier> postalAddressIdentifierList = new List <PostalAddressIdentifier>()
{
new PostalAddressIdentifier()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
locationList = new List <Location>()
{
new Location()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <UserRoleLocation> userRoleLocationList = new List <UserRoleLocation>()
{
new UserRoleLocation()
{
LocationID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
UserID = userId
}
};
postcodeHierarchyList = new List <PostcodeHierarchy>()
{
new PostcodeHierarchy()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
PostcodeTypeGUID = postcodeTypeGUID,
ParentPostcode = "111",
Postcode = "123",
}
};
List <Postcode> postcodeList = new List <Postcode>()
{
new Postcode()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
InwardCode = "a",
OutwardCode = "b",
PostcodeUnit = "unit1",
}
};
List <LocationReferenceData> locationReferenceDataList = new List <LocationReferenceData>()
{
new LocationReferenceData()
{
LocationID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <LocationPostcodeHierarchy> locationPostcodeHierarchyList = new List <LocationPostcodeHierarchy>()
{
new LocationPostcodeHierarchy()
{
PostcodeHierarchyID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
LocationID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
mockUnitManagerDbContext = CreateMock <UnitManagerDbContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for PostalAddressIdentifier
var mockAsynEnumerable1 = new DbAsyncEnumerable <PostalAddressIdentifier>(postalAddressIdentifierList);
var mockPostalAddressIdentifier = MockDbSet(postalAddressIdentifierList);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockPostalAddressIdentifier.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddressIdentifier>)mockAsynEnumerable1).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostalAddressIdentifier>()).Returns(mockPostalAddressIdentifier.Object);
mockUnitManagerDbContext.Setup(x => x.PostalAddressIdentifiers).Returns(mockPostalAddressIdentifier.Object);
mockUnitManagerDbContext.Setup(c => c.PostalAddressIdentifiers.AsNoTracking()).Returns(mockPostalAddressIdentifier.Object);
// Setup for Location
var mockAsynEnumerable2 = new DbAsyncEnumerable <Location>(locationList);
var mockLocation = MockDbSet(locationList);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable2).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockUnitManagerDbContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockUnitManagerDbContext.Setup(c => c.Locations.AsNoTracking()).Returns(mockLocation.Object);
// Setup for UserRoleLocation
var mockAsynEnumerable3 = new DbAsyncEnumerable <UserRoleLocation>(userRoleLocationList);
var mockUserRoleLocation = MockDbSet(userRoleLocationList);
mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockUserRoleLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockUserRoleLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <UserRoleLocation>)mockAsynEnumerable3).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <UserRoleLocation>()).Returns(mockUserRoleLocation.Object);
mockUnitManagerDbContext.Setup(x => x.UserRoleLocations).Returns(mockUserRoleLocation.Object);
mockUnitManagerDbContext.Setup(c => c.UserRoleLocations.AsNoTracking()).Returns(mockUserRoleLocation.Object);
// Setup for PostcodeHierarchy
var mockAsynEnumerable4 = new DbAsyncEnumerable <PostcodeHierarchy>(postcodeHierarchyList);
var mockPostcodeHierarchy = MockDbSet(postcodeHierarchyList);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
mockPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostcodeHierarchy>)mockAsynEnumerable4).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostcodeHierarchy>()).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.PostcodeHierarchies).Returns(mockPostcodeHierarchy.Object);
// Setup for Postcode
var mockAsynEnumerable5 = new DbAsyncEnumerable <Postcode>(postcodeList);
var mockPostcode = MockDbSet(postcodeList);
mockPostcode.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable5.AsQueryable().Provider);
mockPostcode.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable5.AsQueryable().Expression);
mockPostcode.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable5.AsQueryable().ElementType);
mockPostcode.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Postcode>)mockAsynEnumerable5).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <Postcode>()).Returns(mockPostcode.Object);
mockUnitManagerDbContext.Setup(x => x.Postcodes).Returns(mockPostcode.Object);
mockUnitManagerDbContext.Setup(c => c.Postcodes.AsNoTracking()).Returns(mockPostcode.Object);
// Setup for Postcode
var mockAsynEnumerable6 = new DbAsyncEnumerable <LocationReferenceData>(locationReferenceDataList);
var mockLocationReferenceData = MockDbSet(locationReferenceDataList);
mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable6.AsQueryable().Provider);
mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable6.AsQueryable().Expression);
mockLocationReferenceData.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable6.AsQueryable().ElementType);
mockLocationReferenceData.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationReferenceData>)mockAsynEnumerable6).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <LocationReferenceData>()).Returns(mockLocationReferenceData.Object);
mockUnitManagerDbContext.Setup(x => x.LocationReferenceDatas).Returns(mockLocationReferenceData.Object);
// Setup for LocationPostcodeHierarchy
var mockAsynEnumerable7 = new DbAsyncEnumerable <LocationPostcodeHierarchy>(locationPostcodeHierarchyList);
var mockLocationPostcodeHierarchy = MockDbSet(locationPostcodeHierarchyList);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable7.AsQueryable().Provider);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable7.AsQueryable().Expression);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable7.AsQueryable().ElementType);
mockLocationPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationPostcodeHierarchy>)mockAsynEnumerable7).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <LocationPostcodeHierarchy>()).Returns(mockLocationPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.LocationPostcodeHierarchies).Returns(mockLocationPostcodeHierarchy.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <UnitManagerDbContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockUnitManagerDbContext.Object);
testCandidate = new UnitLocationDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object);
}
/// <summary>
/// Setup for Nunit Tests
/// </summary>
protected override void OnSetup()
{
// Data Setup
List <Postcode> postcodeList = new List <Postcode>()
{
new Postcode()
{
PostcodeUnit = "123",
InwardCode = "1",
OutwardCode = "2",
ID = new Guid("3534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <PostcodeHierarchy> postcodeHierarchyList = new List <PostcodeHierarchy>()
{
new PostcodeHierarchy()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
PostcodeTypeGUID = postcodeTypeGUID,
ParentPostcode = "111",
Postcode = "123"
}
};
List <LocationPostcodeHierarchy> locationPostcodeHierarchyList = new List <LocationPostcodeHierarchy>()
{
new LocationPostcodeHierarchy()
{
PostcodeHierarchyID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
LocationID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <Location> locationList = new List <Location>()
{
new Location()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <DeliveryPoint> deliveryPointList = new List <DeliveryPoint>()
{
new DeliveryPoint()
{
PostalAddress = new PostalAddress()
{
Postcode = "123"
},
NetworkNode = new NetworkNode()
{
Location = new Location()
{
Shape = unitBoundary
}
}
},
new DeliveryPoint()
{
PostalAddress = new PostalAddress()
{
Postcode = "12"
},
NetworkNode = new NetworkNode()
{
Location = new Location()
{
}
}
}
};
searchInputDataDto = new SearchInputDataDto()
{
SearchText = "12",
PostcodeTypeGUID = postcodeTypeGUID,
SearchResultCount = 2,
UserUnitLocationId = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
};
List <PostalAddressIdentifier> postalAddressIdentifierList = new List <PostalAddressIdentifier>()
{
new PostalAddressIdentifier()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
mockUnitManagerDbContext = CreateMock <UnitManagerDbContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for PostcodeHierarchy
var mockAsynEnumerable = new DbAsyncEnumerable <PostcodeHierarchy>(postcodeHierarchyList);
var mockPostcodeHierarchy = MockDbSet(postcodeHierarchyList);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostcodeHierarchy>)mockAsynEnumerable).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostcodeHierarchy>()).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.PostcodeHierarchies).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(c => c.PostcodeHierarchies.AsNoTracking()).Returns(mockPostcodeHierarchy.Object);
// Setup for PostalAddressIdentifier
var mockAsynEnumerable1 = new DbAsyncEnumerable <PostalAddressIdentifier>(postalAddressIdentifierList);
var mockPostalAddressIdentifier = MockDbSet(postalAddressIdentifierList);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockPostalAddressIdentifier.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockPostalAddressIdentifier.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddressIdentifier>)mockAsynEnumerable1).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostalAddressIdentifier>()).Returns(mockPostalAddressIdentifier.Object);
mockUnitManagerDbContext.Setup(x => x.PostalAddressIdentifiers).Returns(mockPostalAddressIdentifier.Object);
mockUnitManagerDbContext.Setup(c => c.PostalAddressIdentifiers.AsNoTracking()).Returns(mockPostalAddressIdentifier.Object);
// Setup for LocationPostcodeHierarchy
var mockAsynEnumerable2 = new DbAsyncEnumerable <LocationPostcodeHierarchy>(locationPostcodeHierarchyList);
var mockLocationPostcodeHierarchy = MockDbSet(locationPostcodeHierarchyList);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockLocationPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationPostcodeHierarchy>)mockAsynEnumerable2).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <LocationPostcodeHierarchy>()).Returns(mockLocationPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.LocationPostcodeHierarchies).Returns(mockLocationPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(c => c.LocationPostcodeHierarchies.AsNoTracking()).Returns(mockLocationPostcodeHierarchy.Object);
// Setup for Location
var mockAsynEnumerable3 = new DbAsyncEnumerable <Location>(locationList);
var mockLocation = MockDbSet(locationList);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable3).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockUnitManagerDbContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockUnitManagerDbContext.Setup(c => c.Locations.AsNoTracking()).Returns(mockLocation.Object);
// Setup for Postcode
var mockAsynEnumerable4 = new DbAsyncEnumerable <Postcode>(postcodeList);
var mockPostcode = MockDbSet(postcodeList);
mockPostcode.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
mockPostcode.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
mockPostcode.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
mockPostcode.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Postcode>)mockAsynEnumerable4).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <Postcode>()).Returns(mockPostcode.Object);
mockUnitManagerDbContext.Setup(x => x.Postcodes).Returns(mockPostcode.Object);
// Setup for DeliveryPoint
var mockAsynEnumerable5 = new DbAsyncEnumerable <DeliveryPoint>(deliveryPointList);
var mockDeliveryPoint = MockDbSet(deliveryPointList);
mockDeliveryPoint.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable5.AsQueryable().Provider);
mockDeliveryPoint.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable5.AsQueryable().Expression);
mockDeliveryPoint.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable5.AsQueryable().ElementType);
mockDeliveryPoint.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPoint>)mockAsynEnumerable5).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <DeliveryPoint>()).Returns(mockDeliveryPoint.Object);
mockUnitManagerDbContext.Setup(x => x.DeliveryPoints).Returns(mockDeliveryPoint.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <UnitManagerDbContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockUnitManagerDbContext.Object);
testCandidate = new PostcodeDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
loggingHelperMock = CreateMock <ILoggingHelper>();
unit1Guid = Guid.NewGuid();
unit2Guid = Guid.NewGuid();
unit3Guid = Guid.NewGuid();
user1Id = System.Guid.NewGuid();
user2Id = System.Guid.NewGuid();
var unitBoundary = DbGeometry.PolygonFromText("POLYGON ((505058.162109375 100281.69677734375, 518986.84887695312 100281.69677734375, 518986.84887695312 114158.546875, 505058.162109375 114158.546875, 505058.162109375 100281.69677734375))", 27700);
accessLinkLine = DbGeometry.LineFromText("LINESTRING (488938 197021, 488929.9088937093 197036.37310195228)", 27700);
var streetNames = new List <StreetName>()
{
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad1", DesignatedName = "XYZ1", Geometry = unitBoundary
},
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad2", DesignatedName = "XYZ2", Geometry = unitBoundary
},
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad3", DesignatedName = "XYZ3", Geometry = unitBoundary
},
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad4", DesignatedName = "XYZ4", Geometry = unitBoundary
},
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad5", DesignatedName = "XYZ5", Geometry = unitBoundary
},
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad6", DesignatedName = "XYZ6", Geometry = unitBoundary
},
new StreetName()
{
ID = Guid.NewGuid(), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad7", DesignatedName = "XYZ7", Geometry = unitBoundary
}
};
var unitLocation = new List <UnitLocation>()
{
new UnitLocation()
{
UnitName = "unit1", ExternalId = "extunit1", ID = unit1Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit1Guid, User_GUID = user1Id
}
}
},
new UnitLocation()
{
UnitName = "unit2", ExternalId = "extunit2", ID = unit2Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit2Guid, User_GUID = user1Id
}
}
},
new UnitLocation()
{
UnitName = "unit3", ExternalId = "extunit2", ID = unit3Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit3Guid, User_GUID = user2Id
}
}
}
};
var networkLink = new List <NetworkLink>()
{
new NetworkLink()
{
LinkGeometry = accessLinkLine
}
};
var mockAsynEnumerable = new DbAsyncEnumerable <StreetName>(streetNames);
var mockStreetNetworkDataService = MockDbSet(streetNames);
mockStreetNetworkDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockStreetNetworkDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockStreetNetworkDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockStreetNetworkDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <StreetName>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <StreetName>()).Returns(mockStreetNetworkDataService.Object);
mockRMDBContext.Setup(x => x.StreetNames).Returns(mockStreetNetworkDataService.Object);
var mockAsynEnumerable2 = new DbAsyncEnumerable <UnitLocation>(unitLocation);
var mockStreetNetworkDataService2 = MockDbSet(unitLocation);
mockStreetNetworkDataService2.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockStreetNetworkDataService2.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockStreetNetworkDataService2.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockStreetNetworkDataService2.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <UnitLocation>)mockAsynEnumerable2).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <UnitLocation>()).Returns(mockStreetNetworkDataService2.Object);
mockRMDBContext.Setup(x => x.UnitLocations).Returns(mockStreetNetworkDataService2.Object);
var mockAsynEnumerable3 = new DbAsyncEnumerable <NetworkLink>(networkLink);
var mockNetworkLink = MockDbSet(networkLink);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockNetworkLink.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <NetworkLink>)mockAsynEnumerable3).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <NetworkLink>()).Returns(mockNetworkLink.Object);
mockRMDBContext.Setup(x => x.NetworkLinks).Returns(mockNetworkLink.Object);
mockRMDBContext.Setup(x => x.NetworkLinks.AsNoTracking()).Returns(mockNetworkLink.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new StreetNetworkDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
/// <summary>
/// Setup for Nunit Tests
/// </summary>
protected override void OnSetup()
{
// Data Setup
List <PostcodeHierarchy> postcodeHierarchyList = new List <PostcodeHierarchy>()
{
new PostcodeHierarchy()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
PostcodeTypeGUID = postcodeTypeGUID,
ParentPostcode = "111",
Postcode = "123",
}
};
List <LocationPostcodeHierarchy> locationPostcodeHierarchyList = new List <LocationPostcodeHierarchy>()
{
new LocationPostcodeHierarchy()
{
PostcodeHierarchyID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918"),
LocationID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <Location> locationList = new List <Location>()
{
new Location()
{
ID = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
List <PostalAddress> postalAddressList = new List <PostalAddress>()
{
new PostalAddress()
{
UDPRN = 123,
Postcode = "123",
AddressType_GUID = postcodeTypeGUID,
Thoroughfare = "12"
}
};
searchInputDataDto = new SearchInputDataDto()
{
SearchText = "12",
PostcodeTypeGUID = postcodeTypeGUID,
SearchResultCount = 2,
UserUnitLocationId = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
};
mockUnitManagerDbContext = CreateMock <UnitManagerDbContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for PostcodeHierarchy
var mockAsynEnumerable4 = new DbAsyncEnumerable <PostcodeHierarchy>(postcodeHierarchyList);
var mockPostcodeHierarchy = MockDbSet(postcodeHierarchyList);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
mockPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
mockPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostcodeHierarchy>)mockAsynEnumerable4).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostcodeHierarchy>()).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.PostcodeHierarchies).Returns(mockPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(c => c.PostcodeHierarchies.AsNoTracking()).Returns(mockPostcodeHierarchy.Object);
// Setup for LocationPostcodeHierarchy
var mockAsynEnumerable7 = new DbAsyncEnumerable <LocationPostcodeHierarchy>(locationPostcodeHierarchyList);
var mockLocationPostcodeHierarchy = MockDbSet(locationPostcodeHierarchyList);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable7.AsQueryable().Provider);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable7.AsQueryable().Expression);
mockLocationPostcodeHierarchy.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable7.AsQueryable().ElementType);
mockLocationPostcodeHierarchy.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <LocationPostcodeHierarchy>)mockAsynEnumerable7).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <LocationPostcodeHierarchy>()).Returns(mockLocationPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(x => x.LocationPostcodeHierarchies).Returns(mockLocationPostcodeHierarchy.Object);
mockUnitManagerDbContext.Setup(c => c.LocationPostcodeHierarchies.AsNoTracking()).Returns(mockLocationPostcodeHierarchy.Object);
// Setup for Location
var mockAsynEnumerable2 = new DbAsyncEnumerable <Location>(locationList);
var mockLocation = MockDbSet(locationList);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable2).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockUnitManagerDbContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockUnitManagerDbContext.Setup(c => c.Locations.AsNoTracking()).Returns(mockLocation.Object);
// Setup for PostalAddress
var mockAsynEnumerable5 = new DbAsyncEnumerable <PostalAddress>(postalAddressList);
var mockPostalAddress = MockDbSet(postalAddressList);
mockPostalAddress.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable5.AsQueryable().Provider);
mockPostalAddress.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable5.AsQueryable().Expression);
mockPostalAddress.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable5.AsQueryable().ElementType);
mockPostalAddress.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddress>)mockAsynEnumerable5).GetAsyncEnumerator());
mockUnitManagerDbContext.Setup(x => x.Set <PostalAddress>()).Returns(mockPostalAddress.Object);
mockUnitManagerDbContext.Setup(x => x.PostalAddresses).Returns(mockPostalAddress.Object);
mockUnitManagerDbContext.Setup(c => c.PostalAddresses.AsNoTracking()).Returns(mockPostalAddress.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <UnitManagerDbContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockUnitManagerDbContext.Object);
testCandidate = new PostalAddressDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object);
}
/// <summary>
/// Setup for Nunit Tests.
/// </summary>
protected override void OnSetup()
{
mockLoggingHelper = CreateMock <ILoggingHelper>();
unit1Guid = Guid.NewGuid();
unit2Guid = Guid.NewGuid();
unit3Guid = Guid.NewGuid();
user1Id = System.Guid.NewGuid();
user2Id = System.Guid.NewGuid();
var unitBoundary = DbGeometry.PolygonFromText("POLYGON((511570.8590967182 106965.35195621933, 511570.8590967182 107474.95297542136, 512474.1409032818 107474.95297542136, 512474.1409032818 106965.35195621933, 511570.8590967182 106965.35195621933))", 27700);
var location = new List <Location>()
{
new Location()
{
ID = unit1Guid, Shape = unitBoundary
}
};
var networkLinks = new List <NetworkLink>()
{
new NetworkLink()
{
LinkGeometry = unitBoundary,
}
};
var networkLink = new NetworkLink()
{
LinkGeometry = unitBoundary,
};
var accessLink = new List <AccessLink>()
{
new AccessLink()
{
ID = Guid.NewGuid(), NetworkLink = networkLink
}
};
var deliveryPoint = new List <DeliveryPoint>()
{
new DeliveryPoint()
{
NetworkNode = new NetworkNode()
{
Location = new Location()
{
Shape = unitBoundary
}
}
}
};
var networkNodeDataDTO = new NetworkNodeDataDTO()
{
ID = Guid.NewGuid(),
Location = new LocationDataDTO()
{
ID = Guid.NewGuid(),
Shape = unitBoundary,
RowCreateDateTime = DateTime.UtcNow
}
};
var accessLinkDataDTOs = new AccessLinkDataDTO()
{
Approved = true,
ID = Guid.NewGuid(),
WorkloadLengthMeter = 40,
LinkDirectionGUID = Guid.NewGuid(),
ConnectedNetworkLinkID = Guid.NewGuid(),
AccessLinkTypeGUID = Guid.NewGuid()
};
var accessLinkStatus = new AccessLinkStatusDataDTO()
{
ID = Guid.NewGuid(),
NetworkLinkID = Guid.NewGuid(),
AccessLinkStatusGUID = Guid.NewGuid(),
StartDateTime = DateTime.UtcNow,
RowCreateDateTime = DateTime.UtcNow
};
netWorkLinkDataDto = new NetworkLinkDataDTO()
{
ID = Guid.NewGuid(),
DataProviderGUID = Guid.NewGuid(),
NetworkLinkTypeGUID = Guid.NewGuid(),
StartNodeID = Guid.NewGuid(),
EndNodeID = Guid.NewGuid(),
LinkLength = 40,
LinkGeometry = unitBoundary,
RowCreateDateTime = DateTime.UtcNow,
};
var mockAsynEnumerable = new DbAsyncEnumerable <AccessLink>(accessLink);
mockFmoDbContext = CreateMock <AccessLinkDBContext>();
mockFmoDbContext.Setup(x => x.SaveChanges()).Returns(1);
var mockAccessLinkDataService = MockDbSet(accessLink);
mockFmoDbContext.Setup(x => x.Set <AccessLink>()).Returns(mockAccessLinkDataService.Object);
mockFmoDbContext.Setup(x => x.AccessLinks).Returns(mockAccessLinkDataService.Object);
// mockFmoDbContext.Setup(c => c.AccessLinks.AsNoTracking()).Returns(mockAccessLinkDataService.Object);
mockAccessLinkDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessLinkDataService.Object);
mockAccessLinkDataService.Setup(x => x.AsNoTracking()).Returns(mockAccessLinkDataService.Object);
var mockAccessLinkDataService1 = MockDbSet(networkLinks);
mockFmoDbContext.Setup(x => x.Set <NetworkLink>()).Returns(mockAccessLinkDataService1.Object);
mockFmoDbContext.Setup(x => x.NetworkLinks).Returns(mockAccessLinkDataService1.Object);
// mockFmoDbContext.Setup(c => c.NetworkLinks.AsNoTracking()).Returns(mockAccessLinkDataService1.Object);
mockAccessLinkDataService1.Setup(x => x.AsNoTracking()).Returns(mockAccessLinkDataService1.Object);
var mockAccessLinkDataService4 = MockDbSet(deliveryPoint);
mockFmoDbContext.Setup(x => x.Set <DeliveryPoint>()).Returns(mockAccessLinkDataService4.Object);
mockFmoDbContext.Setup(x => x.DeliveryPoints).Returns(mockAccessLinkDataService4.Object);
mockAccessLinkDataService4.Setup(x => x.AsNoTracking()).Returns(mockAccessLinkDataService4.Object);
var mockAsynEnumerable2 = new DbAsyncEnumerable <Location>(location);
var mockAccessLinkDataService2 = MockDbSet(location);
mockFmoDbContext.Setup(x => x.Set <Location>()).Returns(mockAccessLinkDataService2.Object);
mockFmoDbContext.Setup(x => x.Locations).Returns(mockAccessLinkDataService2.Object);
mockFmoDbContext.Setup(c => c.Locations.AsNoTracking()).Returns(mockAccessLinkDataService2.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <AccessLinkDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockFmoDbContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new AccessLinkDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
mockLoggingHelper = CreateMock <ILoggingHelper>();
unit1Guid = Guid.NewGuid();
unit2Guid = Guid.NewGuid();
unit3Guid = Guid.NewGuid();
user1Id = System.Guid.NewGuid();
user2Id = System.Guid.NewGuid();
var unitBoundary = DbGeometry.PolygonFromText("POLYGON((511570.8590967182 106965.35195621933, 511570.8590967182 107474.95297542136, 512474.1409032818 107474.95297542136, 512474.1409032818 106965.35195621933, 511570.8590967182 106965.35195621933))", 27700);
var unitLocation = new List <UnitLocation>()
{
new UnitLocation()
{
UnitName = "unit1", ExternalId = "extunit1", ID = unit1Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit1Guid, User_GUID = user1Id
}
}
},
new UnitLocation()
{
UnitName = "unit2", ExternalId = "extunit2", ID = unit2Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit2Guid, User_GUID = user1Id
}
}
},
new UnitLocation()
{
UnitName = "unit3", ExternalId = "extunit2", ID = unit3Guid, UnitBoundryPolygon = unitBoundary, UserRoleUnits = new List <UserRoleUnit> {
new UserRoleUnit {
Unit_GUID = unit3Guid, User_GUID = user2Id
}
}
}
};
var accessLink = new List <AccessLink>()
{
new AccessLink()
{
AccessLinkLine = unitBoundary,
ID = Guid.NewGuid()
}
};
accessLinkDto = new AccessLinkDTO()
{
OperationalObjectPoint = DbGeometry.PointFromText("POINT (488938 197021)", 27700),
NetworkIntersectionPoint = null,
AccessLinkLine = null,
ActualLengthMeter = 3,
WorkloadLengthMeter = 5,
Approved = true,
OperationalObject_GUID = Guid.NewGuid()
};
var mockAsynEnumerable = new DbAsyncEnumerable <AccessLink>(accessLink);
var mockAccessLinkDataService = MockDbSet(accessLink);
mockFmoDbContext = CreateMock <RMDBContext>();
mockFmoDbContext.Setup(x => x.Set <AccessLink>()).Returns(mockAccessLinkDataService.Object);
mockFmoDbContext.Setup(x => x.AccessLinks).Returns(mockAccessLinkDataService.Object);
mockFmoDbContext.Setup(c => c.AccessLinks.AsNoTracking()).Returns(mockAccessLinkDataService.Object);
mockAccessLinkDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessLinkDataService.Object);
var mockAsynEnumerable2 = new DbAsyncEnumerable <UnitLocation>(unitLocation);
var mockAccessLinkDataService2 = MockDbSet(unitLocation);
mockFmoDbContext.Setup(x => x.Set <UnitLocation>()).Returns(mockAccessLinkDataService2.Object);
mockFmoDbContext.Setup(x => x.UnitLocations).Returns(mockAccessLinkDataService2.Object);
mockFmoDbContext.Setup(c => c.UnitLocations.AsNoTracking()).Returns(mockAccessLinkDataService2.Object);
mockAccessLinkDataService2.Setup(x => x.Include(It.IsAny <string>())).Returns(mockAccessLinkDataService2.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockFmoDbContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new AccessLinkDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
List <BlockSequence> blockSequence = new List <BlockSequence>()
{
};
mockLoggingHelper = CreateMock <ILoggingHelper>();
blockSequenceDTO = new BlockSequenceDTO()
{
Block_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A11")
};
var blocks = new List <Block>()
{
new Block()
{
ID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A16"), BlockType = "U"
}
};
var deliveryRouteBlocks = new List <DeliveryRouteBlock>()
{
new DeliveryRouteBlock()
{
Block_GUID = new Guid("019DBBBB-03FB-489C-8C8D-F1085E0D2A16"), DeliveryRoute_GUID = new Guid("119DBBBB-03FB-489C-8C8D-F1085E0D2A13")
}
};
var mockBlockSequenceDataServiceEnumerable = new DbAsyncEnumerable <BlockSequence>(blockSequence);
var mockBlockSequenceDataServiceDataService = MockDbSet(blockSequence);
mockBlockSequenceDataServiceDataService.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockBlockSequenceDataServiceEnumerable.AsQueryable().Provider);
mockBlockSequenceDataServiceDataService.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockBlockSequenceDataServiceEnumerable.AsQueryable().Expression);
mockBlockSequenceDataServiceDataService.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockBlockSequenceDataServiceEnumerable.AsQueryable().ElementType);
mockBlockSequenceDataServiceDataService.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <BlockSequence>)mockBlockSequenceDataServiceEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <BlockSequence>()).Returns(mockBlockSequenceDataServiceDataService.Object);
mockRMDBContext.Setup(x => x.BlockSequences).Returns(mockBlockSequenceDataServiceDataService.Object);
mockBlockSequenceDataServiceDataService.Setup(x => x.Include(It.IsAny <string>())).Returns(mockBlockSequenceDataServiceDataService.Object);
mockRMDBContext.Setup(c => c.BlockSequences.AsNoTracking()).Returns(mockBlockSequenceDataServiceDataService.Object);
var mockBlockEnumerable = new DbAsyncEnumerable <Block>(blocks);
var mockBlock = MockDbSet(blocks);
mockBlock.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockBlockEnumerable.AsQueryable().Provider);
mockBlock.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockBlockEnumerable.AsQueryable().Expression);
mockBlock.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockBlockEnumerable.AsQueryable().ElementType);
mockBlock.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Block>)mockBlockEnumerable).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <Block>()).Returns(mockBlock.Object);
mockRMDBContext.Setup(x => x.Blocks).Returns(mockBlock.Object);
mockBlock.Setup(x => x.Include(It.IsAny <string>())).Returns(mockBlock.Object);
mockRMDBContext.Setup(c => c.Blocks.AsNoTracking()).Returns(mockBlock.Object);
var mockDeliveryRouteBlockEnumerable = new DbAsyncEnumerable <DeliveryRouteBlock>(deliveryRouteBlocks);
var mockDeliveryRouteBlock = MockDbSet(deliveryRouteBlocks);
mockDeliveryRouteBlock.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockDeliveryRouteBlockEnumerable.AsQueryable().Provider);
mockDeliveryRouteBlock.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockDeliveryRouteBlockEnumerable.AsQueryable().Expression);
mockDeliveryRouteBlock.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockDeliveryRouteBlockEnumerable.AsQueryable().ElementType);
mockDeliveryRouteBlock.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryRouteBlock>)mockDeliveryRouteBlockEnumerable).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryRouteBlock>()).Returns(mockDeliveryRouteBlock.Object);
mockRMDBContext.Setup(x => x.DeliveryRouteBlocks).Returns(mockDeliveryRouteBlock.Object);
mockDeliveryRouteBlock.Setup(x => x.Include(It.IsAny <string>())).Returns(mockDeliveryRouteBlock.Object);
mockRMDBContext.Setup(c => c.DeliveryRouteBlocks.AsNoTracking()).Returns(mockDeliveryRouteBlock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockLoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
testCandidate = new BlockSequenceDataService(mockDatabaseFactory.Object, mockLoggingHelper.Object);
}
/// <summary>
/// Data and Methods setup required to run test methods
/// </summary>
protected override void OnSetup()
{
// Data setup
unit1Guid = new Guid("8534AA41-391F-4579-A18D-D7EDF5B5F918");
currentUserUnitType = "Delivery Office";
mockIConfigurationHelper = CreateMock <IConfigurationHelper>();
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
var unitBoundary = DbGeometry.PolygonFromText("POLYGON ((505058.162109375 100281.69677734375, 518986.84887695312 100281.69677734375, 518986.84887695312 114158.546875, 505058.162109375 114158.546875, 505058.162109375 100281.69677734375))", 27700);
accessLinkLine = DbGeometry.LineFromText("LINESTRING (488938 197021, 488929.9088937093 197036.37310195228)", 27700);
point = DbGeometry.PointFromText("POINT (488938 197021)", 27700);
var streetNamesList = new List <StreetName>()
{
new StreetName()
{
ID = new Guid("8134AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad1", DesignatedName = "XYZ1", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8234AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad2", DesignatedName = "XYZ2", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8334AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad3", DesignatedName = "XYZ3", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8434AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad4", DesignatedName = "XYZ4", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8534AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad5", DesignatedName = "XYZ5", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8634AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad6", DesignatedName = "XYZ6", Geometry = unitBoundary
},
new StreetName()
{
ID = new Guid("8734AA41-391F-4579-A18D-D7EDF5B5F918"), StreetType = "t1", Descriptor = "d1", NationalRoadCode = "Testroad7", DesignatedName = "XYZ7", Geometry = unitBoundary
}
};
var networkLinkList = new List <NetworkLink>()
{
new NetworkLink()
{
LinkGeometry = accessLinkLine,
StreetNameGUID = new Guid("8134AA41-391F-4579-A18D-D7EDF5B5F918"),
NetworkLinkTypeGUID = Guid.Empty,
ID = new Guid("8134AA41-391F-4579-A18D-D7EDF5B5F911")
}
};
List <Location> locationList = new List <Location>()
{
new Location()
{
ID = unit1Guid,
Shape = unitBoundary
}
};
referenceDataCategoryList = new List <ReferenceDataCategoryDTO>()
{
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.NetworkLinkType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataValue = ReferenceDataValues.NetworkLinkPathLink
}
},
Id = new Guid("1534AA41-391F-4579-A18D-D7EDF5B5F918")
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.NetworkLinkType,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataValue = ReferenceDataValues.NetworkLinkRoadLink
}
},
Id = new Guid("2534AA41-391F-4579-A18D-D7EDF5B5F918")
},
new ReferenceDataCategoryDTO()
{
CategoryName = ReferenceDataCategoryNames.AccessLinkParameters,
ReferenceDatas = new List <ReferenceDataDTO>()
{
new ReferenceDataDTO()
{
ReferenceDataName = ReferenceDataValues.AccessLinkDiffRoadMaxDistance,
ReferenceDataValue = "5"
}
},
Id = new Guid("3534AA41-391F-4579-A18D-D7EDF5B5F918")
}
};
mockNetworkDBContext = CreateMock <NetworkDBContext>();
mockILoggingHelper = CreateMock <ILoggingHelper>();
// Setup for StreetName
var mockAsynEnumerable = new DbAsyncEnumerable <StreetName>(streetNamesList);
var mockStreetName = MockDbSet(streetNamesList);
mockStreetName.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockStreetName.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockStreetName.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockStreetName.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <StreetName>)mockAsynEnumerable).GetAsyncEnumerator());
mockNetworkDBContext.Setup(x => x.Set <StreetName>()).Returns(mockStreetName.Object);
mockNetworkDBContext.Setup(x => x.StreetNames).Returns(mockStreetName.Object);
mockStreetName.Setup(x => x.AsNoTracking()).Returns(mockStreetName.Object);
// Setup for Location
var mockAsynEnumerable1 = new DbAsyncEnumerable <Location>(locationList);
var mockLocation = MockDbSet(locationList);
mockLocation.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockLocation.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockLocation.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockLocation.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Location>)mockAsynEnumerable1).GetAsyncEnumerator());
mockNetworkDBContext.Setup(x => x.Set <Location>()).Returns(mockLocation.Object);
mockNetworkDBContext.Setup(x => x.Locations).Returns(mockLocation.Object);
mockLocation.Setup(x => x.AsNoTracking()).Returns(mockLocation.Object);
// Setup for NetworkLink
var mockAsynEnumerable3 = new DbAsyncEnumerable <NetworkLink>(networkLinkList);
var mockNetworkLink = MockDbSet(networkLinkList);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockNetworkLink.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockNetworkLink.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <NetworkLink>)mockAsynEnumerable3).GetAsyncEnumerator());
mockNetworkDBContext.Setup(x => x.Set <NetworkLink>()).Returns(mockNetworkLink.Object);
mockNetworkDBContext.Setup(x => x.NetworkLinks).Returns(mockNetworkLink.Object);
mockNetworkDBContext.Setup(x => x.NetworkLinks.AsNoTracking()).Returns(mockNetworkLink.Object);
// Mock trace manager
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
mockILoggingHelper.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockIConfigurationHelper.Setup(x => x.ReadAppSettingsConfigurationValues(It.IsAny <string>())).Returns("5");
mockDatabaseFactory = CreateMock <IDatabaseFactory <NetworkDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockNetworkDBContext.Object);
testCandidate = new StreetNetworkDataService(mockDatabaseFactory.Object, mockILoggingHelper.Object, mockIConfigurationHelper.Object);
}
protected void SetUpNew()
{
var scenario = new List <Scenario>()
{
new Scenario()
{
ScenarioName = "ScanarioName", ID = scenarioId, Unit_GUID = deliveryUnitID
}
};
var referenceData = new List <ReferenceData>()
{
new ReferenceData()
{
DisplayText = "shared van", ID = refDataId
}
};
var deliveryrouteblocks = new List <DeliveryRouteBlock>()
{
new DeliveryRouteBlock()
{
DeliveryRoute_GUID = deliveryRouteId
}
};
var blocks = new List <Block>()
{
new Block()
{
ID = deliveryRouteId
}
};
var blocksequence = new List <BlockSequence>()
{
new BlockSequence()
{
Block_GUID = deliveryRouteId, OperationalObject_GUID = Guid.NewGuid()
}
};
var deliverypoint = new List <DeliveryPoint>()
{
new DeliveryPoint()
{
ID = Guid.NewGuid()
}
};
var deliverypointalias = new List <DeliveryPointAlias>()
{
new DeliveryPointAlias()
{
DeliveryPoint_GUID = Guid.NewGuid()
}
};
var postaladdress = new List <PostalAddress>()
{
new PostalAddress()
{
ID = Guid.NewGuid()
}
};
var postcode = new List <Postcode>()
{
new Postcode()
{
ID = Guid.NewGuid()
}
};
loggingHelperMock = CreateMock <ILoggingHelper>();
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
var deliveryRoute = new List <DeliveryRoute>()
{
new DeliveryRoute()
{
ID = deliveryRouteId,
RouteName = "Linkroad",
RouteNumber = "1",
Scenario = scenario[0],
ReferenceData = referenceData[0],
RouteMethodType_GUID = refDataId,
DeliveryScenario_GUID = scenarioId,
TravelInTimeMin = 10,
TravelOutTimeMin = 15,
TravelInTransportType_GUID = Guid.NewGuid(),
TravelOutTransportType_GUID = Guid.NewGuid()
}
};
var mockAsynEnumerable1 = new DbAsyncEnumerable <DeliveryRoute>(deliveryRoute);
var mockDeliveryRouteDBSet = MockDbSet(deliveryRoute);
mockReferenceDataCategoryDataService = CreateMock <IReferenceDataCategoryDataService>();
mockDeliveryRouteDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable1.AsQueryable().Provider);
mockDeliveryRouteDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable1.AsQueryable().Expression);
mockDeliveryRouteDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable1.AsQueryable().ElementType);
mockDeliveryRouteDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryRoute>)mockAsynEnumerable1).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <DeliveryRoute>()).Returns(mockDeliveryRouteDBSet.Object);
mockRMDBContext.Setup(x => x.DeliveryRoutes).Returns(mockDeliveryRouteDBSet.Object);
mockRMDBContext.Setup(c => c.DeliveryRoutes.AsNoTracking()).Returns(mockDeliveryRouteDBSet.Object);
var mockAsynEnumerable2 = new DbAsyncEnumerable <ReferenceData>(referenceData);
var mockReferenceDataDBSet = MockDbSet(referenceData);
mockReferenceDataDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable2.AsQueryable().Provider);
mockReferenceDataDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable2.AsQueryable().Expression);
mockReferenceDataDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable2.AsQueryable().ElementType);
mockReferenceDataDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <ReferenceData>)mockAsynEnumerable2).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <ReferenceData>()).Returns(mockReferenceDataDBSet.Object);
mockRMDBContext.Setup(x => x.ReferenceDatas).Returns(mockReferenceDataDBSet.Object);
var mockAsynEnumerable3 = new DbAsyncEnumerable <Scenario>(scenario);
var mockScenarioDBSet = MockDbSet(scenario);
mockScenarioDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable3.AsQueryable().Provider);
mockScenarioDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable3.AsQueryable().Expression);
mockScenarioDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable3.AsQueryable().ElementType);
mockScenarioDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Scenario>)mockAsynEnumerable3).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <Scenario>()).Returns(mockScenarioDBSet.Object);
mockRMDBContext.Setup(x => x.Scenarios).Returns(mockScenarioDBSet.Object);
mockRMDBContext.Setup(c => c.Scenarios.AsNoTracking()).Returns(mockScenarioDBSet.Object);
var mockAsynEnumerable4 = new DbAsyncEnumerable <DeliveryRouteBlock>(deliveryrouteblocks);
var mockDeliveryRouteBlockDBSet = MockDbSet(deliveryrouteblocks);
mockDeliveryRouteBlockDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable4.AsQueryable().Provider);
mockDeliveryRouteBlockDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable4.AsQueryable().Expression);
mockDeliveryRouteBlockDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable4.AsQueryable().ElementType);
mockDeliveryRouteBlockDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryRouteBlock>)mockAsynEnumerable4).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryRouteBlock>()).Returns(mockDeliveryRouteBlockDBSet.Object);
mockRMDBContext.Setup(x => x.DeliveryRouteBlocks).Returns(mockDeliveryRouteBlockDBSet.Object);
mockRMDBContext.Setup(c => c.DeliveryRouteBlocks.AsNoTracking()).Returns(mockDeliveryRouteBlockDBSet.Object);
var mockAsynEnumerable5 = new DbAsyncEnumerable <Block>(blocks);
var mockBlockDBSet = MockDbSet(blocks);
mockBlockDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable5.AsQueryable().Provider);
mockBlockDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable5.AsQueryable().Expression);
mockBlockDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable5.AsQueryable().ElementType);
mockBlockDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Block>)mockAsynEnumerable5).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <Block>()).Returns(mockBlockDBSet.Object);
mockRMDBContext.Setup(x => x.Blocks).Returns(mockBlockDBSet.Object);
mockRMDBContext.Setup(c => c.Blocks.AsNoTracking()).Returns(mockBlockDBSet.Object);
var mockAsynEnumerable6 = new DbAsyncEnumerable <BlockSequence>(blocksequence);
var mockBlockSequenceDBSet = MockDbSet(blocksequence);
mockBlockSequenceDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable6.AsQueryable().Provider);
mockBlockSequenceDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable6.AsQueryable().Expression);
mockBlockSequenceDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable6.AsQueryable().ElementType);
mockBlockSequenceDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <BlockSequence>)mockAsynEnumerable6).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <BlockSequence>()).Returns(mockBlockSequenceDBSet.Object);
mockRMDBContext.Setup(x => x.BlockSequences).Returns(mockBlockSequenceDBSet.Object);
mockRMDBContext.Setup(c => c.BlockSequences.AsNoTracking()).Returns(mockBlockSequenceDBSet.Object);
var mockAsynEnumerable7 = new DbAsyncEnumerable <DeliveryPoint>(deliverypoint);
var mockDeliveryPointDBSet = MockDbSet(deliverypoint);
mockDeliveryPointDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable7.AsQueryable().Provider);
mockDeliveryPointDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable7.AsQueryable().Expression);
mockDeliveryPointDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable7.AsQueryable().ElementType);
mockDeliveryPointDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPoint>)mockAsynEnumerable7).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryPoint>()).Returns(mockDeliveryPointDBSet.Object);
mockRMDBContext.Setup(x => x.DeliveryPoints).Returns(mockDeliveryPointDBSet.Object);
mockRMDBContext.Setup(c => c.DeliveryPoints.AsNoTracking()).Returns(mockDeliveryPointDBSet.Object);
var mockAsynEnumerable8 = new DbAsyncEnumerable <DeliveryPointAlias>(deliverypointalias);
var mockDeliveryPointAliasDBSet = MockDbSet(deliverypointalias);
mockDeliveryPointAliasDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable8.AsQueryable().Provider);
mockDeliveryPointAliasDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable8.AsQueryable().Expression);
mockDeliveryPointAliasDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable8.AsQueryable().ElementType);
mockDeliveryPointAliasDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryPointAlias>)mockAsynEnumerable8).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <DeliveryPointAlias>()).Returns(mockDeliveryPointAliasDBSet.Object);
mockRMDBContext.Setup(x => x.DeliveryPointAlias).Returns(mockDeliveryPointAliasDBSet.Object);
mockRMDBContext.Setup(c => c.DeliveryPointAlias.AsNoTracking()).Returns(mockDeliveryPointAliasDBSet.Object);
var mockAsynEnumerable9 = new DbAsyncEnumerable <PostalAddress>(postaladdress);
var mockPostalAddressDBSet = MockDbSet(postaladdress);
mockPostalAddressDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable9.AsQueryable().Provider);
mockPostalAddressDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable9.AsQueryable().Expression);
mockPostalAddressDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable9.AsQueryable().ElementType);
mockPostalAddressDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <PostalAddress>)mockAsynEnumerable9).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <PostalAddress>()).Returns(mockPostalAddressDBSet.Object);
mockRMDBContext.Setup(x => x.PostalAddresses).Returns(mockPostalAddressDBSet.Object);
mockRMDBContext.Setup(c => c.PostalAddresses.AsNoTracking()).Returns(mockPostalAddressDBSet.Object);
var mockAsynEnumerable10 = new DbAsyncEnumerable <Postcode>(postcode);
var mockPostcodeDBSet = MockDbSet(postcode);
mockPostcodeDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable10.AsQueryable().Provider);
mockPostcodeDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable10.AsQueryable().Expression);
mockPostcodeDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable10.AsQueryable().ElementType);
mockPostcodeDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <Postcode>)mockAsynEnumerable10).GetAsyncEnumerator());
mockRMDBContext.Setup(x => x.Set <Postcode>()).Returns(mockPostcodeDBSet.Object);
mockRMDBContext.Setup(x => x.Postcodes).Returns(mockPostcodeDBSet.Object);
mockRMDBContext.Setup(c => c.Postcodes.AsNoTracking()).Returns(mockPostcodeDBSet.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
testCandidate = new DeliveryRouteDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
protected override void OnSetup()
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
var deliveryRoute = new List <DeliveryRoute>()
{
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch1jbcjkdsghfjks", RouteNumber = "testsearch1jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
},
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch2jbcjkdsghfjks", RouteNumber = "testsearch2jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
},
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch3jbcjkdsghfjks", RouteNumber = "testsearch3jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
},
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch4jbcjkdsghfjks", RouteNumber = "testsearch4jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
},
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch5jbcjkdsghfjks", RouteNumber = "testsearch5jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
},
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch6jbcjkdsghfjks", RouteNumber = "testsearch6jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
},
new DeliveryRoute()
{
ID = Guid.NewGuid(), OperationalStatus_GUID = Guid.NewGuid(), DeliveryScenario_GUID = Guid.NewGuid(), RouteName = "testsearch7jbcjkdsghfjks", RouteNumber = "testsearch7jbcjkdsghfjks", Scenario = new Scenario()
{
Unit_GUID = new Guid("7654810D-3EBF-420A-91FD-DABE05945A44")
}
}
};
var mockAsynEnumerable = new DbAsyncEnumerable <DeliveryRoute>(deliveryRoute);
loggingHelperMock = CreateMock <ILoggingHelper>();
var mockDeliveryRouteDBSet = MockDbSet(deliveryRoute);
mockReferenceDataCategoryDataService = CreateMock <IReferenceDataCategoryDataService>();
mockDeliveryRouteDBSet.As <IQueryable>().Setup(mock => mock.Provider).Returns(mockAsynEnumerable.AsQueryable().Provider);
mockDeliveryRouteDBSet.As <IQueryable>().Setup(mock => mock.Expression).Returns(mockAsynEnumerable.AsQueryable().Expression);
mockDeliveryRouteDBSet.As <IQueryable>().Setup(mock => mock.ElementType).Returns(mockAsynEnumerable.AsQueryable().ElementType);
mockDeliveryRouteDBSet.As <IDbAsyncEnumerable>().Setup(mock => mock.GetAsyncEnumerator()).Returns(((IDbAsyncEnumerable <DeliveryRoute>)mockAsynEnumerable).GetAsyncEnumerator());
mockRMDBContext = CreateMock <RMDBContext>();
mockRMDBContext.Setup(x => x.Set <DeliveryRoute>()).Returns(mockDeliveryRouteDBSet.Object);
mockRMDBContext.Setup(x => x.DeliveryRoutes).Returns(mockDeliveryRouteDBSet.Object);
mockRMDBContext.Setup(c => c.DeliveryRoutes.AsNoTracking()).Returns(mockDeliveryRouteDBSet.Object);
var rmTraceManagerMock = new Mock <IRMTraceManager>();
rmTraceManagerMock.Setup(x => x.StartTrace(It.IsAny <string>(), It.IsAny <Guid>()));
loggingHelperMock.Setup(x => x.RMTraceManager).Returns(rmTraceManagerMock.Object);
mockDatabaseFactory = CreateMock <IDatabaseFactory <RMDBContext> >();
mockDatabaseFactory.Setup(x => x.Get()).Returns(mockRMDBContext.Object);
testCandidate = new DeliveryRouteDataService(mockDatabaseFactory.Object, loggingHelperMock.Object);
}
