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 GetTaxInfo_GivenAnExistingCountryAndProvince_ReturnsRecordFromDatabase()
{
// arrange
var data = new List <SalesTaxInfo>()
{
new SalesTaxInfo()
{
Country = "Canada",
Province = "Quebec",
Federal = 0.05f,
Provincial = 0.0975f
}
};
var expected = data[0];
Mock <DbSet <SalesTaxInfo> > mockTaxesSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <AccountingDb> mockContext = new Mock <AccountingDb>();
mockContext.Setup(c => c.Taxes).Returns(mockTaxesSet.Object);
SalesTaxRepository sut = new SalesTaxRepository(mockContext.Object);
// act
var actual = sut.GetTaxInfo("Canada", "Quebec");
// assert
mockContext.Verify(c => c.Taxes, Times.Once());
Assert.AreEqual(expected.Federal, actual.Federal);
Assert.AreEqual(expected.Provincial, actual.Provincial);
}
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 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));
}
public void AddTaxInfo_GivenAnExistingTaxInfo_ThrowsException()
{
// arrange
SalesTaxInfo duplicateTax = new SalesTaxInfo()
{
Country = "Canada",
Province = "Quebec"
};
var data = new List <SalesTaxInfo>()
{
new SalesTaxInfo()
{
Country = "Canada",
Province = "Quebec"
}
};
Mock <DbSet <SalesTaxInfo> > mockTaxesSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <AccountingDb> mockContext = new Mock <AccountingDb>();
mockContext.Setup(c => c.Taxes).Returns(mockTaxesSet.Object);
SalesTaxRepository sut = new SalesTaxRepository(mockContext.Object);
// act
sut.AddTaxInfo(duplicateTax);
// assert
// exception should be thrown
}
public void UodateTaxInfo_GivenAnUpdatedInfo_UpdatesRecordInDatabase()
{
// arrange
SalesTaxInfo update = new SalesTaxInfo()
{
Country = "Canada",
Province = "Quebec",
Federal = 0.05f,
Provincial = 0.0975f
};
var data = new List <SalesTaxInfo>()
{
new SalesTaxInfo()
{
Country = "Canada",
Province = "Quebec",
Federal = 0.12f,
Provincial = 0.04f
}
};
var actual = data[0];
Mock <DbSet <SalesTaxInfo> > mockTaxesSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <AccountingDb> mockContext = new Mock <AccountingDb>();
mockContext.Setup(c => c.Taxes).Returns(mockTaxesSet.Object);
SalesTaxRepository sut = new SalesTaxRepository(mockContext.Object);
// act
sut.UpdateTaxInfo(update);
// assert
mockContext.Verify(c => c.Taxes, Times.Once());
Assert.AreEqual(0.05f, actual.Federal);
Assert.AreEqual(0.0975f, actual.Provincial);
}
public void UpdateStock_GivenAValidItemIDAndANewStockValue_UpdatesTheRecord()
{
// arrange
List <InventoryItem> data = new List <InventoryItem>();
data.Add(new InventoryItem()
{
ID = 12, UnitsInStock = 3
});
data.Add(new InventoryItem()
{
ID = 20, UnitsInStock = 40
});
data.Add(new InventoryItem()
{
ID = 18, UnitsInStock = 31
});
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
sut.UpdateStock(20, 50);
// assert
Assert.AreEqual(50, data[1].UnitsInStock);
mockContext.Verify(c => c.SaveChanges(), Times.Once());
}
public void UpdateStock_GivenAValidItemIDAndTheSameStockValue_IngnoresAndDoesNothing()
{
// arrange
List <InventoryItem> data = new List <InventoryItem>();
data.Add(new InventoryItem()
{
ID = 1, UnitsInStock = 1
});
data.Add(new InventoryItem()
{
ID = 2, UnitsInStock = 12
});
data.Add(new InventoryItem()
{
ID = 21, UnitsInStock = 50
});
data.Add(new InventoryItem()
{
ID = 18, UnitsInStock = 31
});
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
sut.UpdateStock(21, 50);
// assert
Assert.AreEqual(50, data[2].UnitsInStock);
mockContext.Verify(c => c.SaveChanges(), Times.Never());
}
public void RemoveWarehouse_GivenAnInstance_RemovesTheRecord()
{
// assert
List <Warehouse> data = new List <Warehouse>();
data.Add(new Warehouse()
{
ID = 10
});
Warehouse existingRecord = new Warehouse()
{
ID = 10
};
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
sut.RemoveWarehouse(existingRecord);
// assert
mockSet.Verify(s => s.Attach(It.Is <Warehouse>(a => a.ID == 10)), Times.Once());
mockSet.Verify(s => s.Remove(It.Is <Warehouse>(a => a.ID == 10)), Times.Once());
mockContext.Verify(c => c.SaveChanges(), Times.Once());
}
public void GetCategoryID_GivenAValidName_ReturnsTheID()
{
// arrange
List <ProductCategory> data = new List <ProductCategory>();
data.Add(new ProductCategory()
{
ID = 1, Name = "Food"
});
data.Add(new ProductCategory()
{
ID = 2, Name = "Beverage"
});
data.Add(new ProductCategory()
{
ID = 3, Name = "Stationary"
});
data.Add(new ProductCategory()
{
ID = 4, Name = "Health"
});
int expected = data[1].ID;
Mock <DbSet <ProductCategory> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <InventoryDb> mockContext = new Mock <InventoryDb>();
mockContext.Setup(c => c.Categories).Returns(mockSet.Object);
ProductCategoryRepository sut = new ProductCategoryRepository(mockContext.Object);
// act
int actual = sut.GetCategoryID("Beverage");
// assert
Assert.AreEqual(expected, actual);
}
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 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 GetStock_GivenAValidWarehouseAndProductID_ReturnsItsStockInTheWarehouse()
{
// arrange
Warehouse warehouse = new Warehouse()
{
ID = 15
};
List <InventoryItem> data = new List <InventoryItem>();
data.Add(new InventoryItem()
{
WarehouseID = 11, ProductID = 100
});
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
});
InventoryItem expected = data[5];
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.GetStock(warehouse, 150);
// assert
Assert.AreEqual(expected, actual);
}
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 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 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 GetWarehouse_GivenAnIDOnNonEmptyRecords_RetunsTheWarehouseRecord()
{
// arrange
List <Warehouse> data = new List <Warehouse>();
data.Add(new Warehouse()
{
ID = 1, Name = "Warehouse 1"
});
data.Add(new Warehouse()
{
ID = 2, Name = "Warehouse 2"
});
data.Add(new Warehouse()
{
ID = 3, Name = "Warehouse 3"
});
data.Add(new Warehouse()
{
ID = 4, Name = "Warehouse 4"
});
data.Add(new Warehouse()
{
ID = 5, Name = "Warehouse 5"
});
Warehouse expected = data[2];
Mock <DbSet <Warehouse> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
mockSet.Setup(s => s.Find(It.IsIn(2))).Returns(data[2]);
Mock <LocationDb> mockContext = new Mock <LocationDb>();
mockContext.Setup(c => c.Warehouses).Returns(mockSet.Object);
WarehouseRepository sut = new WarehouseRepository(mockContext.Object, null);
// act
Warehouse actual = sut.GetWarehouse(2);
// assert
mockSet.Verify(s => s.Find(It.IsIn(2)), Times.Once());
Assert.IsTrue(expected.Equals(actual));
}
public void GetRegion_GivenANameOnNonEmptyDatabase_ReturnsTheRegionRecord()
{
// arrange
List <Region> data = new List <Region>();
Region expected = new Region {
ID = 1, Continent = "North America", Country = "Canada", Name = "Eastern Canada", Provinces = null
};
data.Add(expected);
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
Region actual = sut.GetRegion("Eastern Canada");
// assert
Assert.IsTrue(expected.Equals(actual));
}
public void AddWarehouse_GivenANewWarehouse_AddsToRecords()
{
// assert
List <Warehouse> data = new List <Warehouse>();
Warehouse newRecord = new Warehouse()
{
ID = 10
};
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
sut.AddWarehouse(newRecord);
// assert
mockSet.Verify(s => s.Add(It.Is <Warehouse>(a => a.ID == 10)), Times.Once());
mockContext.Verify(c => c.SaveChanges(), Times.Once());
}
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));
}
public void AddRegion_OnAnEmptyTable_AddsTheNewRecord()
{
// arrange
List <Region> data = new List <Region>();
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
Region region = new Region {
ID = 1, Continent = "North America", Country = "Canada", Name = "Eastern Canada", Provinces = null
};
sut.AddRegion(region);
// assert
mockSet.Verify(s => s.Add(It.IsAny <Region>()), Times.Once());
mockContext.Verify(c => c.SaveChanges(), Times.Once());
}
public void GetShipper_GivenAValidName_ReturnsTheRecordFromDatabase()
{
// arrange
List <Shipper> data = new List <Shipper>();
data.Add(new Shipper()
{
ID = 100, Name = "DHL"
});
Mock <DbSet <Shipper> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <ShippingDb> mockContext = new Mock <ShippingDb>();
mockContext.Setup(c => c.Shippers).Returns(mockSet.Object);
ShipperRepository sut = new ShipperRepository(mockContext.Object);
// act
Shipper actual = sut.GetShipper("DHL");
// assert
Assert.AreEqual(data[0], actual);
}
public void GetPeyment_GivenAValidOrderID_ReturnsThePaymentRecord()
{
// arrange
List <PaymentInfo> data = new List <PaymentInfo>();
PaymentInfo expected = new PaymentInfo()
{
OrderID = 210
};
data.Add(expected);
Mock <DbSet <PaymentInfo> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <AccountingDb> mockContext = new Mock <AccountingDb>();
mockContext.Setup(c => c.Payments).Returns(mockSet.Object);
PaymentInfoRepository sut = new PaymentInfoRepository(mockContext.Object);
// act
PaymentInfo actual = sut.GetPayment(210);
// assert
Assert.AreEqual(expected, actual);
}
public void GetAllRegionsByCountry_GivenAValidCountryOnNonEmptyRecords_RetunsTheRelatedRegions()
{
// arrange
List <Region> data = new List <Region>();
data.Add(new Region()
{
ID = 1, Country = "Canada"
});
data.Add(new Region()
{
ID = 2, Country = "US"
});
data.Add(new Region()
{
ID = 3, Country = "Canada"
});
data.Add(new Region()
{
ID = 4, Country = "Canada"
});
List <Region> expected = new List <Region>();
expected.Add(data[0]);
expected.Add(data[2]);
expected.Add(data[3]);
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.GetAllRegionsByCountry("Canada");
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void AddTaxInfo_GivenANewTaxInfo_AddsToTheDatabase()
{
// arrange
SalesTaxInfo newTax = new SalesTaxInfo()
{
Country = "Canada",
Province = "Ontario"
};
List <SalesTaxInfo> data = new List <SalesTaxInfo>();
Mock <DbSet <SalesTaxInfo> > mockTaxesSet = EntityMockFactory.CreateSet(data.AsQueryable());
Mock <AccountingDb> mockContext = new Mock <AccountingDb>();
mockContext.Setup(c => c.Taxes).Returns(mockTaxesSet.Object);
SalesTaxRepository sut = new SalesTaxRepository(mockContext.Object);
// act
sut.AddTaxInfo(newTax);
// assert
mockContext.Verify(c => c.Taxes, Times.Exactly(2));
mockTaxesSet.Verify(s => s.Add(newTax), Times.Once());
mockContext.Verify(c => c.SaveChanges(), Times.Once());
}
public void GetAllProducts_OnNonEmptyTable_ReturnsAllProducts()
{
// arrange
List <Product> expected = new List <Product>();
expected.Add(new Product()
{
ID = 1
});
expected.Add(new Product()
{
ID = 2
});
expected.Add(new Product()
{
ID = 3
});
expected.Add(new Product()
{
ID = 4
});
expected.Add(new Product()
{
ID = 5
});
Mock <DbSet <Product> > mockSet = EntityMockFactory.CreateSet(expected.AsQueryable());
Mock <InventoryDb> mockContext = new Mock <InventoryDb>();
mockContext.Setup(c => c.Products).Returns(mockSet.Object);
ProductRepository sut = new ProductRepository(mockContext.Object);
// act
var actual = sut.GetAllProducts();
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
public void GetService_GivenAValidID_ReturnsServiceRecordFromDatabase()
{
// arrange
List <DeliveryService> data = new List <DeliveryService>();
data.Add(new DeliveryService()
{
ID = 1, ServiceName = "Service 1"
});
data.Add(new DeliveryService()
{
ID = 2, ServiceName = "Service 2"
});
data.Add(new DeliveryService()
{
ID = 3, ServiceName = "Service 3"
});
data.Add(new DeliveryService()
{
ID = 4, ServiceName = "Service 4"
});
DeliveryService expected = data[2];
Mock <DbSet <DeliveryService> > mockSet = EntityMockFactory.CreateSet(data.AsQueryable());
mockSet.Setup(s => s.Find(It.Is <int>(a => a == 3))).Returns(expected);
Mock <ShippingDb> mockContext = new Mock <ShippingDb>();
mockContext.Setup(c => c.Services).Returns(mockSet.Object);
DeliveryServiceRepository sut = new DeliveryServiceRepository(mockContext.Object);
// act
DeliveryService actual = sut.GetService(3);
// assert
Assert.AreEqual(expected, actual);
}
public void GetInventories_GivenAValidListOfWarehouses_ReturnsTheirInventories()
{
List <Warehouse> warehouses = new List <Warehouse>();
warehouses.Add(new Warehouse()
{
ID = 21
});
warehouses.Add(new Warehouse()
{
ID = 22
});
warehouses.Add(new Warehouse()
{
ID = 23
});
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 = 22
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 23
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 24
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 24
});
data.Add(new InventoryItem()
{
ID = 1, WarehouseID = 25
});
List <InventoryItem> expected = new List <InventoryItem>();
expected.Add(data[1]);
expected.Add(data[2]);
expected.Add(data[3]);
expected.Add(data[4]);
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.GetInventories(warehouses);
// assert
Assert.IsTrue(Equality.AreEqual(expected, actual));
}
