public void TestFeetConverter()
{
IDimensionModule dimensionFeet = new DimensionFeet();
Assert.True(Equality.AreEqual(26.24672, dimensionFeet.FromSI(8)));
Assert.True(Equality.AreEqual(9.1439997, dimensionFeet.ToSI(30)));
}
public void GetStocksByRegion_ResultExistsInCache_ReturnsTheResult()
{
// arrange
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(new InventoryItem()
{
UnitsInStock = 120
});
expected.Add(new InventoryItem()
{
UnitsInStock = 140
});
expected.Add(new InventoryItem()
{
UnitsInStock = 130
});
expected.Add(new InventoryItem()
{
UnitsInStock = 150
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.Setup(c => c["stocksOfP300InEasternCanadaRegion"]).Returns(expected);
InventoryService sut = new InventoryService(null, null, null, mockCache.Object, null);
// act
var actual = sut.GetStocksByRegion("EasternCanada", 300);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(c => c["stocksOfP300InEasternCanadaRegion"], Times.Once());
}
public void GetAllRegions_OnNonEmptyTable_ReturnsAllRegions()
{
// arrange
List <Region> data = new List <Region>();
data.Add(new Region {
ID = 1, Continent = "North America", Country = "Canada", Name = "Eastern Canada", Provinces = null
});
data.Add(new Region {
ID = 2, Continent = "North America", Country = "Canada", Name = "Northern Canada", Provinces = null
});
data.Add(new Region {
ID = 3, Continent = "North America", Country = "Canada", Name = "Western Canada", Provinces = null
});
Mock <DbSet <Region> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <LocationDb> mockContext = new Mock <LocationDb>();
mockContext.Setup(c => c.Regions).Returns(mockSet.Object);
RegionRepository sut = new RegionRepository(mockContext.Object);
// act
IEnumerable <Region> actual = sut.GetAllRegions();
// assert
Assert.IsTrue(Equality.AreEqual(data, actual));
}
public void GetStocksByCity_ResultExistsInCache_ReturnsTheResult()
{
// arrange
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(new InventoryItem()
{
UnitsInStock = 12
});
expected.Add(new InventoryItem()
{
UnitsInStock = 14
});
expected.Add(new InventoryItem()
{
UnitsInStock = 13
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.Setup(c => c["stocksOfP100InToronto"]).Returns(expected);
InventoryService sut = new InventoryService(null, null, null, mockCache.Object, null);
// act
var actual = sut.GetStocksByCity("Toronto", 100);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(c => c["stocksOfP100InToronto"], Times.Once());
}
public void GetAllShippers_ResultExistsInCache_ReturnsTheListOfShippers()
{
// arrange
List <Shipper> expected = new List <Shipper>();
expected.Add(new Shipper()
{
ID = 1
});
expected.Add(new Shipper()
{
ID = 2
});
expected.Add(new Shipper()
{
ID = 3
});
expected.Add(new Shipper()
{
ID = 4
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.Setup(c => c["allShippers"]).Returns(expected);
ShippingService sut = new ShippingService(null, null, null, mockCache.Object);
// act
var actual = sut.GetAllShippers();
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(c => c["allShippers"], Times.Once());
}
public void GetInventoryByCity_ResultExistsInCache_ReturnsTheResult()
{
// arrange
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(new InventoryItem()
{
ID = 1
});
expected.Add(new InventoryItem()
{
ID = 2
});
expected.Add(new InventoryItem()
{
ID = 3
});
expected.Add(new InventoryItem()
{
ID = 4
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.Setup(c => c["inventoryInVancouver"]).Returns(expected);
InventoryService sut = new InventoryService(null, null, null, mockCache.Object, null);
// act
var actual = sut.GetInventoryByCity("Vancouver");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(c => c["inventoryInVancouver"], Times.Once());
}
public void GetOrdersByCustomer_GivenAValidCustomerIDAndAPeriodOfTime_ReturnsAppropriateRecords()
{
// arrange
List <Order> data = new List <Order>();
data.Add(new Order()
{
CustomerID = "12", OrderDate = new DateTime(2015, 4, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "13", OrderDate = new DateTime(2015, 4, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "12", OrderDate = new DateTime(2015, 5, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "12", OrderDate = new DateTime(2015, 6, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "12", OrderDate = new DateTime(2015, 7, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "15", OrderDate = new DateTime(2015, 4, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "16", OrderDate = new DateTime(2015, 4, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "17", OrderDate = new DateTime(2015, 4, 1), ParentOrderID = -1
});
data.Add(new Order()
{
CustomerID = "12", OrderDate = new DateTime(2015, 8, 1), ParentOrderID = -1
});
List <Order> expected = new List <Order>();
expected.Add(data[0]);
expected.Add(data[2]);
expected.Add(data[3]);
expected.Add(data[4]);
expected.Add(data[8]);
Mock <DbSet <Order> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <OrderDb> mockContext = new Mock <OrderDb>();
mockContext.Setup(c => c.Orders).Returns(mockSet.Object);
OrderRepository sut = new OrderRepository(mockContext.Object);
// act
var actual = sut.GetOrdersByCustomer("12", new DateTime(2015, 1, 1), new DateTime(2016, 1, 1));
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetCategories_ResultNotExistsInCache_FetchesTheResultFromDatabase()
{
// arrange
List <ProductCategory> expected = new List <ProductCategory>();
expected.Add(new ProductCategory()
{
ID = 1
});
expected.Add(new ProductCategory()
{
ID = 2
});
expected.Add(new ProductCategory()
{
ID = 3
});
Mock <IProductCategoryRepository> mockCategoryRepo = new Mock <IProductCategoryRepository>();
mockCategoryRepo.Setup(r => r.GetAllCategories()).Returns(expected);
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
InventoryService sut = new InventoryService(null, mockCategoryRepo.Object, null, mockCache.Object, null);
// act
var actual = sut.GetCategories();
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCategoryRepo.Verify(r => r.GetAllCategories(), Times.Once());
}
public void GetCategories_ResultExistsInCache_ReturnsTheResult()
{
// arrange
List <ProductCategory> expected = new List <ProductCategory>();
expected.Add(new ProductCategory()
{
ID = 1
});
expected.Add(new ProductCategory()
{
ID = 2
});
expected.Add(new ProductCategory()
{
ID = 3
});
expected.Add(new ProductCategory()
{
ID = 4
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.Setup(c => c["allCategories"]).Returns(expected);
InventoryService sut = new InventoryService(null, null, null, mockCache.Object, null);
// act
var actual = sut.GetCategories();
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(c => c["allCategories"], Times.Once());
}
public void GetStock_GivenAValidListOfWarehousesAndAProductID_ReturnsTheStocksInTheWarehouses()
{
// arrange
List <Warehouse> warehouses = new List <Warehouse>();
warehouses.Add(new Warehouse()
{
ID = 11
});
warehouses.Add(new Warehouse()
{
ID = 15
});
warehouses.Add(new Warehouse()
{
ID = 12
});
List <InventoryItem> data = new List <InventoryItem>();
data.Add(new InventoryItem()
{
WarehouseID = 11, ProductID = 101
});
data.Add(new InventoryItem()
{
WarehouseID = 15, ProductID = 101
});
data.Add(new InventoryItem()
{
WarehouseID = 12, ProductID = 101
});
data.Add(new InventoryItem()
{
WarehouseID = 15, ProductID = 130
});
data.Add(new InventoryItem()
{
WarehouseID = 14, ProductID = 120
});
data.Add(new InventoryItem()
{
WarehouseID = 15, ProductID = 150
});
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(data[0]);
expected.Add(data[1]);
expected.Add(data[2]);
Mock <DbSet <InventoryItem> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <InventoryDb> mockContext = new Mock <InventoryDb>();
mockContext.Setup(c => c.Inventories).Returns(mockSet.Object);
InventoryItemRepository sut = new InventoryItemRepository(mockContext.Object);
// act
var actual = sut.GetStocks(warehouses, 101);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
private IntersectionData?Intersection(Point3D a, Point3D b, double z)
{
if ((Equality.AreLessOrEqual(a.Z, z) && Equality.AreLessOrEqual(b.Z, z)) ||
(Equality.AreMoreOrEqual(a.Z, z) && Equality.AreMoreOrEqual(b.Z, z)))
{
return(null);
}
if (Equality.AreEqual(a.X, b.X) && Equality.AreEqual(a.Y, b.Y))
{
return(new IntersectionData(new Point3D(a.X, a.Y, z), a, b));
}
var x = (z - a.Z) * (b.X - a.X) / (b.Z - a.Z) + a.X;
var y = (z - a.Z) * (b.Y - a.Y) / (b.Z - a.Z) + a.Y;
if (Equality.AreEqual(a.X, b.X))
{
return(new IntersectionData(new Point3D(a.X, y, z), a, b));
}
if (Equality.AreEqual(a.Y, b.Y))
{
return(new IntersectionData(new Point3D(x, a.Y, z), a, b));
}
return(new IntersectionData(new Point3D(x, y, z), a, b));
}
public void GetInventory_GivenAValidWarehoue_ReturnsItsInventory()
{
Warehouse warehouse = new Warehouse()
{
ID = 11
};
List <InventoryItem> data = new List <InventoryItem>();
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 20
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 21
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 21
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 11
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 23
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 11
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 11
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 25
});
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(data[3]);
expected.Add(data[5]);
expected.Add(data[6]);
Mock <DbSet <InventoryItem> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <InventoryDb> mockContext = new Mock <InventoryDb>();
mockContext.Setup(c => c.Inventories).Returns(mockSet.Object);
InventoryItemRepository sut = new InventoryItemRepository(mockContext.Object);
// act
var actual = sut.GetInventory(warehouse);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetAllProvinces_GivenAValidCountryName_ReturnsListOfItsProvinces()
{
// arrange
var regionData = new List <Region>()
{
new Region()
{
ID = 1
},
new Region()
{
ID = 2
}
};
var region1Provinces = new List <Province>()
{
new Province()
{
Name = "Province1", RegionID = 1
},
new Province()
{
Name = "Province2", RegionID = 1
}
};
var region2Provinces = new List <Province>()
{
new Province()
{
Name = "Province3", RegionID = 2
},
new Province()
{
Name = "Province4", RegionID = 2
}
};
IEnumerable <Province> expected = new Province[]
{
region1Provinces[0], region1Provinces[1], region2Provinces[0], region2Provinces[1]
};
Mock <IRegionRepository> regionMock = new Mock <IRegionRepository>();
regionMock.Setup(r => r.GetAllRegionsByCountry("Country1")).Returns(regionData);
Mock <IProvinceRepository> provinceMock = new Mock <IProvinceRepository>();
provinceMock.Setup(p => p.GetProvincesForRegion(1)).Returns(region1Provinces);
provinceMock.Setup(p => p.GetProvincesForRegion(2)).Returns(region2Provinces);
Mock <ObjectCache> cacheMock = new Mock <ObjectCache>();
LocationService sut = new LocationService(regionMock.Object, null, provinceMock.Object, cacheMock.Object);
// act
var actual = sut.GetAllProvinces("Country1");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetStocksByCity_ResultNotExistsInCache_FetchesTheResultFromDatabase()
{
// arrange
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(new InventoryItem()
{
UnitsInStock = 120
});
expected.Add(new InventoryItem()
{
UnitsInStock = 140
});
expected.Add(new InventoryItem()
{
UnitsInStock = 130
});
expected.Add(new InventoryItem()
{
UnitsInStock = 150
});
List <Warehouse> warehouses = new List <Warehouse>();
warehouses.Add(new Warehouse()
{
ID = 12
});
warehouses.Add(new Warehouse()
{
ID = 15
});
warehouses.Add(new Warehouse()
{
ID = 17
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
Mock <ILocationService> mockLocationService = new Mock <ILocationService>();
mockLocationService.Setup(s => s.GetWarehousesByCity("Calgary")).Returns(warehouses);
Mock <IInventoryItemRepository> mockInventoryRepo = new Mock <IInventoryItemRepository>();
mockInventoryRepo.Setup(
r => r.GetStocks(It.Is <IEnumerable <Warehouse> >(l => l.Count() == 3), 200)).Returns(expected);
InventoryService sut = new InventoryService(mockInventoryRepo.Object, null, null,
mockCache.Object, mockLocationService.Object);
// act
var actual = sut.GetStocksByCity("Calgary", 200);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockLocationService.Verify(s => s.GetWarehousesByCity("Calgary"), Times.Once());
mockInventoryRepo.Verify(
r => r.GetStocks(It.Is <IEnumerable <Warehouse> >(l => l.Count() == 3), 200), Times.Once());
}
public static void Main()
{
School school = new School("ISEL", "Chelas");
Student s1 = new Student(46049, "Pedro", school, "Portuguese");
Student s2 = new Student(46065, "José", school, "Portuguese");
IEquality eq1 = new Equality(typeof(Student), "Nr", "Name", "School");
bool res1 = eq1.AreEqual(s1, s2);
IEquality eq2 = new Equality(typeof(Student), "School", "Nationality");
bool res2 = eq2.AreEqual(s1, s2);
Console.WriteLine(res1);
Console.WriteLine(res2);
}
public void GetWarehousesByRegion_OnNonEmptyRecords_ReturnsTheRelatedRecords()
{
// arrange
List <Warehouse> data = new List <Warehouse>();
data.Add(new Warehouse()
{
ID = 1, RegionID = 2
});
data.Add(new Warehouse()
{
ID = 2, RegionID = 1
});
data.Add(new Warehouse()
{
ID = 3, RegionID = 2
});
data.Add(new Warehouse()
{
ID = 4, RegionID = 1
});
data.Add(new Warehouse()
{
ID = 5, RegionID = 1
});
List <Warehouse> expected = new List <Warehouse>();
expected.Add(data[0]);
expected.Add(data[2]);
Region region = new Region()
{
ID = 2, Name = "A Test Region"
};
Mock <IRegionRepository> mockRepo = new Mock <IRegionRepository>();
mockRepo.Setup(r => r.GetRegion(It.IsIn("A Test Region"))).Returns(region);
Mock <DbSet <Warehouse> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <LocationDb> mockContext = new Mock <LocationDb>();
mockContext.Setup(c => c.Warehouses).Returns(mockSet.Object);
WarehouseRepository sut = new WarehouseRepository(mockContext.Object, mockRepo.Object);
// act
IEnumerable <Warehouse> actual = sut.GetWarehousesByRegion("A Test Region");
// assert
mockRepo.Verify(r => r.GetRegion(It.IsIn("A Test Region")), Times.Once());
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetAllRegions_ResultExistsInCache_ReturnsTheRelatedRegions()
{
// arrange
IEnumerable <Region> expected = new List <Region>();
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.SetupGet(c => c["allRegionsInCanada"]).Returns(expected);
LocationService sut = new LocationService(null, null, null, mockCache.Object);
// act
IEnumerable <Region> actual = sut.GetAllRegions("Canada");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetWarehouseByCity_ResultNotExistsInCache_FetchesTheResultFromDatabaseAndAddsToCache()
{
// arrange
List <Warehouse> data = new List <Warehouse>();
data.Add(new Warehouse()
{
ID = 1, City = "Montreal"
});
data.Add(new Warehouse()
{
ID = 2, City = "Toronto"
});
data.Add(new Warehouse()
{
ID = 3, City = "Vancouver"
});
data.Add(new Warehouse()
{
ID = 4, City = "Toronto"
});
data.Add(new Warehouse()
{
ID = 5, City = "Montreal"
});
List <Warehouse> expected = new List <Warehouse>();
expected.Add(data[1]);
expected.Add(data[3]);
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
Mock <IWarehouseRepository> mockRepo = new Mock <IWarehouseRepository>();
mockRepo.Setup(r => r.GetWarehousesByCity("Toronto")).Returns(expected);
LocationService sut = new LocationService(null, mockRepo.Object, null, mockCache.Object);
// act
IEnumerable <Warehouse> actual = sut.GetWarehousesByCity("Toronto");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(
c => c.Set(
It.Is <string>(k => k == "warehousesInToronto"),
It.Is <IEnumerable <Warehouse> >(o => o.Equals(expected)),
It.IsAny <CacheItemPolicy>(),
null),
Times.Once());
}
public void GetInventoryByRegion_ResultNotExistsInCache_FetchesTheResultFromDatabase()
{
// arrange
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(new InventoryItem()
{
ID = 1
});
expected.Add(new InventoryItem()
{
ID = 2
});
expected.Add(new InventoryItem()
{
ID = 3
});
List <Warehouse> warehouses = new List <Warehouse>();
warehouses.Add(new Warehouse()
{
ID = 33
});
warehouses.Add(new Warehouse()
{
ID = 22
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
Mock <ILocationService> mockLocationService = new Mock <ILocationService>();
mockLocationService.Setup(s => s.GetWarehousesByRegion("WesternCanada")).Returns(warehouses);
Mock <IInventoryItemRepository> mockInventoryRepo = new Mock <IInventoryItemRepository>();
mockInventoryRepo.Setup(r => r.GetInventories(It.Is <IEnumerable <Warehouse> >(l => l.Count() == 2)))
.Returns(expected);
InventoryService sut = new InventoryService(mockInventoryRepo.Object, null, null,
mockCache.Object, mockLocationService.Object);
// act
var actual = sut.GetInventoryByRegion("WesternCanada");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockLocationService.Verify(s => s.GetWarehousesByRegion("WesternCanada"), Times.Once());
mockInventoryRepo.Verify(r => r.GetInventories(It.Is <IEnumerable <Warehouse> >(l => l.Count() == 2)),
Times.Once());
}
public void GetItemsByOrder_GivenAValidOrderID_ReturnsTheListOfItemsForThatOrder()
{
// arrange
List <OrderItem> data = new List <OrderItem>();
data.Add(new OrderItem()
{
ID = 30, OrderID = 10
});
data.Add(new OrderItem()
{
ID = 31, OrderID = 11
});
data.Add(new OrderItem()
{
ID = 32, OrderID = 11
});
data.Add(new OrderItem()
{
ID = 33, OrderID = 11
});
data.Add(new OrderItem()
{
ID = 34, OrderID = 12
});
data.Add(new OrderItem()
{
ID = 35, OrderID = 12
});
List <OrderItem> expected = new List <OrderItem>();
expected.Add(data[1]);
expected.Add(data[2]);
expected.Add(data[3]);
Mock <DbSet <OrderItem> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <OrderDb> mockContext = new Mock <OrderDb>();
mockContext.Setup(c => c.OrderItems).Returns(mockSet.Object);
OrderItemRepository sut = new OrderItemRepository(mockContext.Object);
// act
var actual = sut.GetItemsByOrder(11);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetWarehousesByProvince_OnNonEmptyRecords_ReturnsRelatedRecords()
{
// arrange
List <Warehouse> data = new List <Warehouse>();
data.Add(new Warehouse()
{
ID = 1, Province = "Alberta"
});
data.Add(new Warehouse()
{
ID = 2, Province = "Prince Edward Island"
});
data.Add(new Warehouse()
{
ID = 3, Province = "British Columbia"
});
data.Add(new Warehouse()
{
ID = 4, Province = "Quebec"
});
data.Add(new Warehouse()
{
ID = 5, Province = "Alberta"
});
data.Add(new Warehouse()
{
ID = 6, Province = "Newfoundland & Labrador"
});
List <Warehouse> expected = new List <Warehouse>();
expected.Add(data[0]);
expected.Add(data[4]);
Mock <DbSet <Warehouse> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <LocationDb> mockContext = new Mock <LocationDb>();
mockContext.Setup(c => c.Warehouses).Returns(mockSet.Object);
WarehouseRepository sut = new WarehouseRepository(mockContext.Object, null);
// act
IEnumerable <Warehouse> actual = sut.GetWarehousesByProvince("Alberta");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetOrder_GivenIdOfAnOrderHavingMultipleSuborders_ReturnsTheFullOrderObject()
{
// arrange
List <Order> orderData = CreateOrderData();
List <OrderItem> orderItemsData = CreateOrderItemsData();
List <Order> expectedSubOrders = new List <Order>();
expectedSubOrders.Add(orderData[3]);
expectedSubOrders.Add(orderData[4]);
List <OrderItem> expectedSubOrdersItems = new List <OrderItem>();
expectedSubOrdersItems.Add(orderItemsData[4]);
expectedSubOrdersItems.Add(orderItemsData[5]);
expectedSubOrdersItems.Add(orderItemsData[6]);
expectedSubOrdersItems.Add(orderItemsData[7]);
Order expected = orderData[2];
Mock <DbSet <Order> > mockOrdersSet = EntityMockFactory.CreateSet(orderData.AsQueryable());
mockOrdersSet.Setup(s => s.Find(5)).Returns(orderData[2]);
Mock <DbSet <OrderItem> > mockOrderItemsSet = EntityMockFactory.CreateSet(orderItemsData.AsQueryable());
Mock <OrderDb> mockContext = new Mock <OrderDb>();
mockContext.Setup(c => c.Orders).Returns(mockOrdersSet.Object);
mockContext.Setup(c => c.OrderItems).Returns(mockOrderItemsSet.Object);
OrderRepository sut = new OrderRepository(mockContext.Object);
// act
var actual = sut.GetOrder(5);
// assert
var actualSubOrders = new List <Order>(actual.SubOrders);
List <OrderItem> actualSubOrderItems = new List <OrderItem>();
foreach (Order o in actualSubOrders)
{
foreach (OrderItem oi in o.Items)
{
actualSubOrderItems.Add(oi);
}
}
Assert.AreEqual(expected, actual);
Assert.IsTrue(Equality.AreEqual(expectedSubOrders, actualSubOrders));
Assert.IsTrue(Equality.AreEqual(expectedSubOrdersItems, actualSubOrderItems));
mockOrdersSet.Verify(s => s.Find(5), Times.Once());
}
public void GetAllRegions_ResultNotExistsInCache_FetchesTheResultFromDatabaseAndAddsToCache()
{
// arrange
List <Region> data = new List <Region>();
data.Add(new Region()
{
ID = 1, Country = "Canada"
});
data.Add(new Region()
{
ID = 2, Country = "Canada"
});
data.Add(new Region()
{
ID = 3, Country = "Germany"
});
data.Add(new Region()
{
ID = 4, Country = "Canada"
});
List <Region> expected = new List <Region>();
expected.Add(data[0]);
expected.Add(data[1]);
expected.Add(data[3]);
Mock <IRegionRepository> mockRepo = new Mock <IRegionRepository>();
mockRepo.Setup(r => r.GetAllRegionsByCountry(It.Is <string>(c => c == "Canada"))).Returns(expected);
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
LocationService sut = new LocationService(mockRepo.Object, null, null, mockCache.Object);
// act
IEnumerable <Region> actual = sut.GetAllRegions("Canada");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockCache.Verify(
c => c.Set(
It.Is <string>(k => k == "allRegionsInCanada"),
It.Is <IEnumerable <Region> >(o => o.Equals(expected)),
It.IsAny <CacheItemPolicy>(),
null),
Times.Once());
}
public void TestVolumes()
{
IVolumeService service = new VolumeService();
TriangulatedSurface surface = new TriangulatedSurface(new [] { new Triangle3D(new Point3D(0, 0, 10), new Point3D(10, 0, 10), new Point3D(0, 10, 10)) });
var result = service.GetVolumeUnderSurface(surface, 10);
Assert.True(Equality.AreEqual(0, result));
result = service.GetVolumeUnderSurface(surface, 20);
Assert.True(Equality.AreEqual(500, result));
surface = new TriangulatedSurface(new [] { new Triangle3D(new Point3D(0, 0, 10), new Point3D(10, 0, 5), new Point3D(0, 10, 10)) });
result = service.GetVolumeUnderSurface(surface, 20);
Assert.True(Equality.AreEqual(500 + 250.0 / 3.0, result));
}
public void GetWarehousesByRegion_ResultExistsInCache_ReturnsTheRelateResult()
{
// arrange
List <Warehouse> expected = new List <Warehouse>();
expected.Add(new Warehouse {
ID = 1, Name = "Warehouse 1"
});
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
mockCache.Setup(c => c["warehousesInTestRegion"]).Returns(expected);
LocationService sut = new LocationService(null, null, null, mockCache.Object);
// act
IEnumerable <Warehouse> actual = sut.GetWarehousesByRegion("TestRegion");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetServicesByShipper_GivenAValidShipperID_ReturnsServicesByShipperFromDatabase()
{
// arrange
List <DeliveryService> data = new List <DeliveryService>();
data.Add(new DeliveryService()
{
ID = 1, ShipperID = 1
});
data.Add(new DeliveryService()
{
ID = 2, ShipperID = 2
});
data.Add(new DeliveryService()
{
ID = 3, ShipperID = 1
});
data.Add(new DeliveryService()
{
ID = 4, ShipperID = 4
});
data.Add(new DeliveryService()
{
ID = 5, ShipperID = 1
});
List <DeliveryService> expected = new List <DeliveryService>();
expected.Add(data[0]);
expected.Add(data[2]);
expected.Add(data[4]);
Mock <DbSet <DeliveryService> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <ShippingDb> mockContext = new Mock <ShippingDb>();
mockContext.Setup(c => c.Services).Returns(mockSet.Object);
DeliveryServiceRepository sut = new DeliveryServiceRepository(mockContext.Object);
// act
IEnumerable <DeliveryService> actual = sut.GetServicesByShipper(1);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetAllShippers_ResultNotExistsInCache_FetchesTheResultFromDatabase()
{
// arrange
List <Shipper> expected = new List <Shipper>();
expected.Add(new Shipper()
{
ID = 1
});
expected.Add(new Shipper()
{
ID = 2
});
expected.Add(new Shipper()
{
ID = 3
});
expected.Add(new Shipper()
{
ID = 4
});
Mock <IShipperRepository> mockShipperRepo = new Mock <IShipperRepository>();
mockShipperRepo.Setup(r => r.GetAllShippers()).Returns(expected);
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
ShippingService sut = new ShippingService(mockShipperRepo.Object, null, null, mockCache.Object);
// act
var actual = sut.GetAllShippers();
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockShipperRepo.Verify(r => r.GetAllShippers(), Times.Once());
mockCache.Verify(
c => c.Set(
It.Is <string>(s => s.Equals("allShippers")),
It.Is <IEnumerable <Shipper> >(l => l.Count() == 4),
It.IsAny <CacheItemPolicy>(),
null),
Times.Once());
}
public void GetServiceByShipper_ResultNotExistsInCahce_FetchesTheResultFromDatabase()
{
// arrange
Shipper ups = new Shipper()
{
ID = 10, Name = "UPS"
};
Mock <IShipperRepository> mockShipperRepo = new Mock <IShipperRepository>();
mockShipperRepo.Setup(r => r.GetShipper(It.Is <string>(s => s.Equals("UPS")))).Returns(ups);
List <DeliveryService> expected = new List <DeliveryService>();
expected.Add(new DeliveryService()
{
ID = 1, ServiceName = "Regular", ShipperID = 10
});
expected.Add(new DeliveryService()
{
ID = 2, ServiceName = "Express", ShipperID = 10
});
Mock <IDeliveryServiceRepository> mockServiceRepo = new Mock <IDeliveryServiceRepository>();
mockServiceRepo.Setup(r => r.GetServicesByShipper(It.Is <int>(i => i == 10))).Returns(expected);
Mock <ObjectCache> mockCache = new Mock <ObjectCache>();
ShippingService sut = new ShippingService(mockShipperRepo.Object, null, mockServiceRepo.Object, mockCache.Object);
// act
var actual = sut.GetServicesByShipper("UPS");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
mockShipperRepo.Verify(r => r.GetShipper(It.Is <string>(s => s.Equals("UPS"))), Times.Once());
mockServiceRepo.Verify(r => r.GetServicesByShipper(It.Is <int>(i => i == 10)), Times.Once());
mockCache.Verify(
c => c.Set(
It.Is <string>(s => s.Equals("servicesByUPS")),
It.Is <IEnumerable <DeliveryService> >(l => l.Count() == 2),
It.IsAny <CacheItemPolicy>(),
null),
Times.Once());
}
public void GetWarehousesByCity_OnNonEmptyRecords_ReturnsRelatedRecords()
{
// arrange
List <Warehouse> data = new List <Warehouse>();
data.Add(new Warehouse()
{
ID = 1, City = "Montreal"
});
data.Add(new Warehouse()
{
ID = 2, City = "Ottawa"
});
data.Add(new Warehouse()
{
ID = 3, City = "Toronto"
});
data.Add(new Warehouse()
{
ID = 4, City = "Montreal"
});
data.Add(new Warehouse()
{
ID = 5, City = "Calgary"
});
List <Warehouse> expected = new List <Warehouse>();
expected.Add(data[0]);
expected.Add(data[3]);
Mock <DbSet <Warehouse> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <LocationDb> mockContext = new Mock <LocationDb>();
mockContext.Setup(c => c.Warehouses).Returns(mockSet.Object);
WarehouseRepository sut = new WarehouseRepository(mockContext.Object, null);
// act
IEnumerable <Warehouse> actual = sut.GetWarehousesByCity("Montreal");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetAllShippers_Always_ReturnsTheWholeShipperRecordsFromDatabase()
{
// arrange
List <Shipper> expected = new List <Shipper>();
expected.Add(new Shipper()
{
ID = 100
});
Mock <DbSet <Shipper> > mockSet = EntityMockFactory.CreateSet(expected.AsQueryable());
Mock <ShippingDb> mockContext = new Mock <ShippingDb>();
mockContext.Setup(c => c.Shippers).Returns(mockSet.Object);
ShipperRepository sut = new ShipperRepository(mockContext.Object);
// act
var actual = sut.GetAllShippers();
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
