private void AddDroppedItem(InventoryItem droppedItem)
{
var existItem = InventoryItem.ExistItem(droppedItem, _client.Character);
_client.Character.Map.Send(string.Format("{0}-{1};{2};0", Packet.CellObject, droppedItem.Cell,
droppedItem.ItemInfos.Id));
if (existItem != null)
{
existItem.Quantity += droppedItem.Quantity;
lock (DatabaseProvider.InventoryItems)
DatabaseProvider.InventoryItems.Remove(droppedItem);
_client.SendPackets(string.Format("{0}{1}|{2}", Packet.ObjectQuantity, existItem.Id,
existItem.Quantity));
}
else
{
droppedItem.Map = null;
droppedItem.Cell = 0;
droppedItem.Character = _client.Character;
InventoryItemRepository.Create(droppedItem, true);
_client.SendPackets(string.Format("{0}{1}", Packet.ObjectAdd, droppedItem.ItemInfo()));
}
}
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 ActionResult Edit([Bind(Include = "WorkingStandardId,WorkingStandardName,IdCode,MaxxamId,ExpiryDate")] WorkingStandardEditViewModel workingStandard)
{
if (ModelState.IsValid)
{
InventoryItemRepository inventoryRepo = _uow.InventoryItemRepository;
var user = _uow.GetCurrentUser();
InventoryItem invItem = inventoryRepo.Get()
.Where(item => item.WorkingStandard != null && item.WorkingStandard.WorkingStandardId == workingStandard.WorkingStandardId)
.FirstOrDefault();
WorkingStandard updateStandard = invItem.WorkingStandard;
updateStandard.IdCode = workingStandard.IdCode;
updateStandard.WorkingStandardName = workingStandard.WorkingStandardName;
updateStandard.LastModifiedBy = user.UserName;
updateStandard.DateModified = DateTime.Today;
updateStandard.ExpiryDate = workingStandard.ExpiryDate;
_uow.WorkingStandardRepository.Update(updateStandard);
//_uow.Commit();
return(RedirectToAction("Index"));
}
return(View(workingStandard));
}
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 UnitOfWork(RestaurantContext context)
{
_context = context;
Adjustments = new AdjustmentRepository(_context);
AdjustmentsItems = new AdjustmentItemRepository(_context);
Branches = new BranchRepository(_context);
Categories = new CategoryRepository(_context);
Customers = new CustomerRepository(_context);
Deliveries = new DeliveryRepository(_context);
DeliveryItems = new DeliveryItemRepository(_context);
Divisions = new DivisionRepository(_context);
Expirations = new ExpirationRepository(_context);
Groups = new GroupRepository(_context);
Stocks = new InventoryItemRepository(_context);
Locations = new LocationRepository(_context);
Units = new MeasurementUnitRepository(_context);
Productions = new ProductionRepository(_context);
Ingredients = new ProductionItemRepository(_context);
Products = new ProductRepository(_context);
Purchases = new PurchaseRepository(_context);
PurchaseItems = new PurchaseItemRepository(_context);
PurchaseOrders = new PurchaseOrderRepository(_context);
PurchaseOrderItems = new PurchaseOrderItemRepository(_context);
SalesInvoices = new SalesInvoiceRepository(_context);
SalesInvoiceItems = new SalesInvoiceItemRepository(_context);
Suppliers = new SupplierRepository(_context);
Transfers = new TransferRepository(_context);
TransferItems = new TransferItemRepository(_context);
Wastages = new WastageRepository(_context);
WastageItems = new WastageItemRepository(_context);
Workers = new WorkerRepository(_context);
ItemLocation = new ItemLocationRepository(_context);
StockHistory = new StockHistoryRepository(_context);
Currencies = new CurrencyRepository(_context);
}
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 Generate(Character character, int quantity = 1)
{
var item = new InventoryItem
{
Id = DatabaseProvider.InventoryItems.Count > 0
? DatabaseProvider.InventoryItems.OrderByDescending(x => x.Id).First().Id + 1
: 1,
Character = character,
ItemInfos = this,
ItemPosition = StatsManager.Position.None,
Stats = ItemStats.GenerateRandomStats(Stats).ToList(),
Quantity = quantity
};
var existItem = InventoryItem.ExistItem(item, item.Character, item.ItemPosition);
if (existItem != null)
{
existItem.Quantity += 1;
InventoryItemRepository.Update(existItem);
}
else
{
InventoryItemRepository.Create(item, true);
}
}
public InventoryItemController(SCMSContext _context)
{
var optionBuilder = new DbContextOptions <SCMSContext>();
_inventoryItemRepository = new InventoryItemRepository(_context);
_inventoryItemService = new InventoryItemService(_inventoryItemRepository);
}
public void Execution_deletes_product_and_associated_inventory_items()
{
var orderProxy = new Mock <IOrderDataProxy>();
orderProxy.Setup(proxy => proxy.GetByProduct(1)).Returns(Enumerable.Empty <Order>());
var product = new Product()
{
ProductID = 1
};
var productDataProxy = new ProductRepository();
productDataProxy.Clear();
productDataProxy.Insert(product);
var inventoryDataProxy = new InventoryItemRepository();
inventoryDataProxy.Clear();
inventoryDataProxy.Insert(new InventoryItem()
{
ProductID = 1
});
var command = new DeleteProductCommand(1, productDataProxy,
new InventoryItemService(inventoryDataProxy),
orderProxy.Object,
new TransactionContextStub());
var result = command.Execute();
result.Success.ShouldBe(true);
result.Errors.ShouldBe(null);
productDataProxy.GetAll().Count().ShouldBe(0);
inventoryDataProxy.GetAll().Count().ShouldBe(0);
}
public ReceiptService(Repository <Receipt> repository,
Repository <ReceiptItem> itemRepository,
InventoryItemRepository inventoryItemRepository) : base(repository)
{
_repository = repository;
_itemRepository = itemRepository;
_inventoryItemRepository = inventoryItemRepository;
}
private ICommand <Product> CreateCommand(Product product)
{
var productDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
var inventoryService = new InventoryItemService(inventoryDataProxy);
return(new CreateProductCommand(product, productDataProxy, inventoryService, new TransactionContextStub()));
}
public UnitOfWork(CoopEshopContext context)
{
ctx = context;
Products = new ProductRepository(ctx);
InventoryItems = new InventoryItemRepository(ctx);
PriceComponents = new PriceComponentRepository(ctx);
}
internal async void OnCurrentInventoryItemIDChanged(object sender, NotificationEventArgs <string> e)
{
using (InventoryItemRepository ctx = new InventoryItemRepository())
{
CurrentInventoryItem = await ctx.GetInventoryItem(e.Data).ConfigureAwait(continueOnCapturedContext: false);
}
NotifyPropertyChanged(m => CurrentInventoryItem);
}
public ReceiptController(SCMSContext _context)
{
var optionBuilder = new DbContextOptions <SCMSContext>();
_receiptRepository = new ReceiptRepository(_context);
_receiptItemRepository = new ReceiptItemRepository(_context);
_inventoryItemRepository = new InventoryItemRepository(_context);
_receiptService = new ReceiptService(_receiptRepository, _receiptItemRepository, _inventoryItemRepository);
}
public MatchStatsBuilder(
ImageRepository imageRepository,
HeroesRepository heroesRepository,
InventoryItemRepository inventoryItemRepository)
{
_imageRepository = imageRepository;
_heroesRepository = heroesRepository;
_inventoryItemRepository = inventoryItemRepository;
}
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 UnitOfWork(MyDbContext context)
{
_context = context;
Users = new UserRepository(_context);
Items = new ItemRepository(_context);
UserDb = new UserDbRepository(_context);
Inventories = new InventoryRepository(_context);
InventoryItems = new InventoryItemRepository(_context);
}
public async Task SelectAll()
{
IEnumerable <InventoryItem> lst = null;
using (var ctx = new InventoryItemRepository())
{
lst = await ctx.GetInventoryItemsByExpressionNav(vloader.FilterExpression, vloader.NavigationExpression).ConfigureAwait(continueOnCapturedContext: false);
}
SelectedInventoryItems = new ObservableCollection <InventoryItem>(lst);
}
void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
var productsDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
_inventoryService = new InventoryItemService(inventoryDataProxy);
_orderItemsService = new OrderItemService(new OrderItemRepository(), productsDataProxy, _inventoryService, new DTCTransactionContext());
_ordersService = new OrderService(new OrderRepository(), _orderItemsService, new DTCTransactionContext());
_customersService = new CustomerService(new CustomerRepository(), _ordersService);
_productsService = new ProductService(productsDataProxy, _ordersService, _inventoryService, new DTCTransactionContext());
_categoriesService = new CategoryService(new CategoryRepository(), _productsService);
this.DataContext = new MainWindowVM(_eventAggregator, _customersService, _productsService, _categoriesService, _ordersService, _inventoryService);
}
public void Product_and_inventory_item_should_be_created()
{
var product = CreateValidProduct();
var productDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
var inventoryService = new InventoryItemService(inventoryDataProxy);
var command = new CreateProductCommand(product, productDataProxy, inventoryService, new TransactionContextStub());
var newProduct = command.Execute().Value;
productDataProxy.GetByID(newProduct.ID).ShouldNotBeNull();
inventoryDataProxy.GetByProduct(newProduct.ID).ShouldNotBeNull();
}
private void UpdateDetailedItem(InventoryItemCreated @event)
{
InventoryItemEntity inventoryItem = new InventoryItemEntity
{
Rsn = @event.Rsn,
Name = @event.Name,
CurrentCount = 0,
IsLogicallyDeleted = false
};
// As this is the first event for this instance, no existing instance will exist, thus a create operation is executed
InventoryItemRepository.Create(inventoryItem);
}
partial void OnGetByRsn(IServiceRequestWithData <ISingleSignOnToken, InventoryItemServiceGetByRsnParameters> serviceRequest, ref IServiceResponseWithResultData <InventoryItemEntity> results)
{
// Define Query
ISingleResultQuery <InventoryItemQueryStrategy, InventoryItemEntity> query = QueryFactory.CreateNewSingleResultQuery <InventoryItemQueryStrategy, InventoryItemEntity>();
query.QueryStrategy.WithRsn(serviceRequest.Data.rsn);
// Retrieve Data, but remember if no items exist, the value is null
query = InventoryItemRepository.Retrieve(query);
InventoryItemEntity inventoryItem = query.Result;
results = new ServiceResponseWithResultData <InventoryItemEntity>(inventoryItem);
}
public void Product_and_inventory_item_should_be_created()
{
var product = CreateValidProduct();
var productDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
var inventoryService = new InventoryItemService(inventoryDataProxy);
var command = new CreateProductCommand(product, productDataProxy, inventoryService, new TransactionContextStub());
var newProduct = command.Execute().Value;
productDataProxy.GetByID(newProduct.ID).ShouldNotBeNull();
inventoryDataProxy.GetByProduct(newProduct.ID).ShouldNotBeNull();
}
private void ConfigureInMemoryUsage()
{
var productsDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
var customerDataProxy = new CustomerRepository();
var orderItemDataProxy = new OrderItemRepository();
var orderRepository = new OrderRepository(customerDataProxy, orderItemDataProxy);
var categoriesDataProxy = new CategoryRepository();
_inventoryService = new InventoryItemService(inventoryDataProxy);
_orderItemsService = new OrderItemService(orderItemDataProxy, productsDataProxy, inventoryDataProxy, new DTCTransactionContext());
_ordersService = new OrderService(orderRepository, _orderItemsService, new DTCTransactionContext());
_customersService = new CustomerService(customerDataProxy, _ordersService);
_productsService = new ProductService(productsDataProxy, orderRepository, _inventoryService, new DTCTransactionContext());
_categoriesService = new CategoryService(categoriesDataProxy, productsDataProxy);
this.DataContext = new MainWindowVM(_eventAggregator, _customersService, _productsService, _categoriesService, _ordersService, _inventoryService);
}
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);
}
private void ConfigureInMemoryUsage()
{
var productsDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
var customerDataProxy = new CustomerRepository();
var orderItemDataProxy = new OrderItemRepository();
var orderRepository = new OrderRepository(customerDataProxy, orderItemDataProxy);
var categoriesDataProxy = new CategoryRepository();
_inventoryService = new InventoryItemService(inventoryDataProxy);
_orderItemsService = new OrderItemService(orderItemDataProxy, productsDataProxy, inventoryDataProxy, new DTCTransactionContext());
_ordersService = new OrderService(orderRepository, _orderItemsService, new DTCTransactionContext());
_customersService = new CustomerService(customerDataProxy, _ordersService);
_productsService = new ProductService(productsDataProxy, orderRepository, _inventoryService, new DTCTransactionContext());
_categoriesService = new CategoryService(categoriesDataProxy, productsDataProxy);
this.DataContext = new MainWindowVM(_eventAggregator, _customersService, _productsService, _categoriesService, _ordersService, _inventoryService);
}
private void RemoveTraderItem(InventoryItem existItemTrader, GameClient traderClient, InventoryItem item)
{
existItemTrader.Quantity -= item.Quantity;
if (existItemTrader.Quantity <= 0)
{
traderClient.SendPackets(string.Format("{0}{1}", Packet.ObjectRemove, existItemTrader.Id));
InventoryItemRepository.Remove(existItemTrader, true);
}
else
{
traderClient.SendPackets(string.Format("{0}{1}|{2}", Packet.ObjectQuantity, existItemTrader.Id,
existItemTrader.Quantity));
InventoryItemRepository.Update(existItemTrader);
}
}
private void DeleteDetailedItem(InventoryItemDeactivated @event)
{
// Define Query
ISingleResultQuery <InventoryItemQueryStrategy, InventoryItemEntity> query = QueryFactory.CreateNewSingleResultQuery <InventoryItemQueryStrategy, InventoryItemEntity>();
query.QueryStrategy.WithRsn(@event.Rsn);
// Retrieve Data, but remember if no items exist, the value is null
query = InventoryItemRepository.Retrieve(query, false);
InventoryItemEntity inventoryItem = query.Result;
// As a previous event will have created this instance we should throw an exception if it is not found.
if (inventoryItem == null)
{
throw new NullReferenceException(string.Format("No entity was found by the id '{0}'", @event.Rsn));
}
InventoryItemRepository.Delete(inventoryItem);
}
private void DeleteItem(string data)
{
var itemId = int.Parse(data.Split('|')[0]);
var quantity = int.Parse(data.Split('|')[1]);
var item =
DatabaseProvider.InventoryItems.Find(
x => x.Id == itemId && x.Character.Id == _client.Character.Id && x.Quantity >= quantity);
if (item == null)
{
return;
}
item.Quantity -= quantity;
if (item.Quantity <= 0)
{
_client.SendPackets(string.Format("{0}{1}", Packet.ObjectRemove, item.Id));
InventoryItemRepository.Remove(item, true);
}
else
{
item.Quantity = quantity;
_client.SendPackets(string.Format("{0}{1}|{2}", Packet.ObjectQuantity, item.Id, item.Quantity));
InventoryItemRepository.Update(item);
}
RefreshCharacterStats();
if (!item.IsEquiped())
{
return;
}
_client.Character.Stats.RemoveItemStats(item.Stats);
_client.Character.Map.Send(string.Format("{0}{1}|{2}", Packet.ObjectAccessories, _client.Character.Id,
_client.Character.GetItemsWheneChooseCharacter()));
}
public void AddToInventory_GivenANewItem_AddsToDatabase()
{
// arrange
InventoryItem item = new InventoryItem()
{
ID = 2
};
List <InventoryItem> data = new List <InventoryItem>();
Mock <DbSet <InventoryItem> > mockSet = new Mock <DbSet <InventoryItem> >();
Mock <InventoryDb> mockContext = new Mock <InventoryDb>();
mockContext.Setup(c => c.Inventories).Returns(mockSet.Object);
InventoryItemRepository sut = new InventoryItemRepository(mockContext.Object);
// act
sut.AddToInventory(item);
// assert
mockSet.Verify(s => s.Add(It.Is <InventoryItem>(i => i.ID == 2)), Times.Once());
mockContext.Verify(c => c.SaveChanges(), Times.Once());
}
// Send to Excel Implementation
public async Task Send2Excel()
{
IEnumerable <InventoryItem> lst = null;
using (var ctx = new InventoryItemRepository())
{
lst = await ctx.GetInventoryItemsByExpressionNav(vloader.FilterExpression, vloader.NavigationExpression).ConfigureAwait(continueOnCapturedContext: false);
}
if (lst == null || !lst.Any())
{
MessageBox.Show("No Data to Send to Excel");
return;
}
var s = new ExportToExcel <InventoryItemExcelLine, List <InventoryItemExcelLine> >
{
dataToPrint = lst.Select(x => new InventoryItemExcelLine
{
ItemNumber = x.ItemNumber,
Description = x.Description,
Category = x.Category,
TariffCode = x.TariffCode,
EntryTimeStamp = x.EntryTimeStamp
}).ToList()
};
using (var sta = new StaTaskScheduler(numberOfThreads: 1))
{
await Task.Factory.StartNew(s.GenerateReport, CancellationToken.None, TaskCreationOptions.None, sta).ConfigureAwait(false);
}
}
public IList <InventoryItem> LoadRange(int startIndex, int count, SortDescriptionCollection sortDescriptions, out int overallCount)
{
try
{
if (FilterExpression == null)
{
FilterExpression = "All";
}
using (var ctx = new InventoryItemRepository())
{
var r = ctx.LoadRange(startIndex, count, FilterExpression, navExp, IncludesLst);
overallCount = r.Result.Item2;
return(r.Result.Item1.ToList());
}
}
catch (Exception ex)
{
StatusModel.Message(ex.Message);
overallCount = 0;
return(new List <InventoryItem>());
}
}
public void Execution_deletes_product_and_associated_inventory_items()
{
var orderProxy = new Mock<IOrderDataProxy>();
orderProxy.Setup(proxy => proxy.GetByProduct(1)).Returns(Enumerable.Empty<Order>());
var product = new Product() { ProductID = 1 };
var productDataProxy = new ProductRepository();
productDataProxy.Clear();
productDataProxy.Insert(product);
var inventoryDataProxy = new InventoryItemRepository();
inventoryDataProxy.Clear();
inventoryDataProxy.Insert(new InventoryItem() { ProductID = 1 });
var command = new DeleteProductCommand(1, productDataProxy,
new InventoryItemService(inventoryDataProxy),
orderProxy.Object,
new TransactionContextStub());
var result = command.Execute();
result.Success.ShouldBe(true);
result.Errors.ShouldBe(null);
productDataProxy.GetAll().Count().ShouldBe(0);
inventoryDataProxy.GetAll().Count().ShouldBe(0);
}
private ICommand<Product> CreateCommand(Product product)
{
var productDataProxy = new ProductRepository();
var inventoryDataProxy = new InventoryItemRepository();
var inventoryService = new InventoryItemService(inventoryDataProxy);
return new CreateProductCommand(product, productDataProxy, inventoryService, new TransactionContextStub());
}
