public void Can_Rebuild_Product_Index()
{
// Arrange
PreTestDataWorker.DeleteAllProducts();
var products = MockProductDataMaker.MockProductCollectionForInserting(ProductCount);
_productService.Save(products);
//// Act
var timer = new Stopwatch();
timer.Start();
ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"].RebuildIndex();
timer.Stop();
Console.Write("Time to index: " + timer.Elapsed.ToString());
//// Assert
var searcher = ExamineManager.Instance.SearchProviderCollection["MerchelloProductSearcher"];
var criteria = searcher.CreateSearchCriteria(Merchello.Examine.IndexTypes.ProductVariant);
criteria.Field("allDocs", "1");
var results = searcher.Search(criteria);
Assert.AreEqual(products.Count(), results.Count());
}
public void Can_Retrieve_A_Product_From_The_Index_By_Sku()
{
//// Arrange
var merchello = new MerchelloHelper(MerchelloContext.Current.Services, false);
var productService = this.PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
productService.Save(product);
this._provider.AddProductToIndex(product);
//// Act
var productDisplay = merchello.Query.Product.GetBySku(product.Sku);
//// Assert
Assert.NotNull(productDisplay);
Assert.AreEqual(product.Key, productDisplay.Key);
}
public void Sum_Of_Product_Prices_Mulitplied_By_Quantity_Equals_Baskets_TotalBasketPrice()
{
//// Arrange
decimal expectedPrice = 0;
var basket = Basket.GetBasket(_customer, _itemCache);
var product1 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
var product2 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
var product3 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
var product4 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
basket.AddItem(product1, product1.Name, 1);
expectedPrice += product1.Price;
basket.AddItem(product2, product2.Name, 2);
expectedPrice += (product2.Price * 2);
basket.AddItem(product3, product3.Name, 3);
expectedPrice += (product3.Price * 3);
basket.AddItem(product4, product4.Name, 4);
expectedPrice += (product4.Price * 4);
//// Act
var basketTotal = basket.TotalBasketPrice;
//// Assert
Assert.AreEqual(expectedPrice, basketTotal);
}
public void Init()
{
_extendedData = new ExtendedDataCollection();
var product = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
_extendedData.AddProductVariantValues(((Product)product).MasterVariant);
}
public void Can_Add_A_New_Product_To_The_Index()
{
PreTestDataWorker.DeleteAllProducts();
//// Arrange
var provider = (ProductIndexer)ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"];
provider.RebuildIndex();
var searcher = ExamineManager.Instance.SearchProviderCollection["MerchelloProductSearcher"];
var productVariantService = PreTestDataWorker.ProductVariantService;
//// Act
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
_productService.Save(product);
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
productVariantService.CreateProductVariantWithKey(product, attributes);
provider.AddProductToIndex(product);
//// Assert
var criteria = searcher.CreateSearchCriteria("productvariant", BooleanOperation.And);
criteria.Field("productKey", product.Key.ToString()).And().Field("master", "true");
ISearchResults results = searcher.Search(criteria);
Assert.IsTrue(results.Count() == 1);
var result = results.First();
Assert.NotNull(result.Fields["productOptions"]);
provider.RebuildIndex();
}
/// <summary>
/// Saves a product record to the database and returns and instance of <see cref="IProduct"/> represents that record
/// </summary>
/// <returns><see cref="IProduct"/></returns>
public IProduct MakeExistingProduct(bool shippable = true, decimal weight = 0, decimal price = 0, bool taxable = true)
{
var product = MockProductDataMaker.MockProductForInserting(shippable, weight, price, taxable);
ProductService.Save(product);
product.AddToCatalogInventory(WarehouseCatalog);
ProductService.Save(product);
return(product);
}
public void Can_RetrieveProductOptions_From_ProductInIndex()
{
//// Arrange
var merchello = new MerchelloHelper(MerchelloContext.Current.Services, false);
var productService = this.PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
product.TrackInventory = true;
product.AddToCatalogInventory(this._warehouse.WarehouseCatalogs.First());
productService.Save(product);
foreach (var variant in product.ProductVariants)
{
variant.CatalogInventories.First().Count = 1;
}
productService.Save(product);
foreach (var p in product.ProductVariants)
{
Assert.AreEqual(1, p.TotalInventoryCount, "Preindexed product variant count");
}
this._provider.AddProductToIndex(product);
//// Act
var productDisplay = merchello.Query.Product.GetByKey(product.Key);
//// Assert
Assert.NotNull(productDisplay);
Assert.IsTrue(productDisplay.ProductOptions.Any());
//http://issues.merchello.com/youtrack/issue/M-604
foreach (var variant in productDisplay.ProductVariants)
{
Assert.AreEqual(1, variant.TotalInventoryCount);
}
Assert.AreEqual(12, productDisplay.TotalInventoryCount, "Total inventory count failed");
}
/// <summary>
/// Saves a collection of products to the database and return a collection of <see cref="IProduct"/> representing that collection
/// </summary>
/// <param name="count"></param>
/// <returns></returns>
public IEnumerable <IProduct> MakeExistingProductCollection(int count)
{
var products = MockProductDataMaker.MockProductCollectionForInserting(count);
foreach (var p in products)
{
ProductService.Save(p);
yield return(p);
}
}
public void Can_Filter_CollectionProducts()
{
//// Arrange
var products = new List <IProduct>();
var p1 = MockProductDataMaker.MockProductForInserting("Tester one", "tester-one", 10M);
var p2 = MockProductDataMaker.MockProductForInserting("Tester two ", "tester-two", 10M);
var p3 = MockProductDataMaker.MockProductForInserting("Mock one", "mock-two", 10M);
var p4 = MockProductDataMaker.MockProductForInserting("Cat", "cat", 10M);
var p5 = MockProductDataMaker.MockProductForInserting("Excluded on", "excluded-one", 10M);
products.Add(p1);
products.Add(p2);
products.Add(p3);
products.Add(p4);
_productService.Save(products);
_productService.Save(p5);
var collection = _entityCollectionService.CreateEntityCollectionWithKey(
EntityType.Product,
_providerKey,
"Filter Collection Test");
//// Act
foreach (var p in products)
{
p.AddToCollection(collection.Key);
}
//// Act
var cats = new List <IProduct>();
var testers = _productService.GetFromCollection(collection.Key, "tester", 1, long.MaxValue);
Assert.IsTrue(testers.Items.Any());
cats.AddRange(testers.Items.Where(x => x.Sku == "cat"));
var ones = _productService.GetFromCollection(collection.Key, "one", 1, long.MaxValue);
Assert.IsTrue(ones.Items.Any());
cats.AddRange(ones.Items.Where(x => x.Sku == "cat"));
var notOnes = ((ProductService)_productService).GetKeysNotInCollection(
collection.Key,
"one",
1,
long.MaxValue);
//// Assert
Assert.AreEqual(2, testers.TotalItems);
Assert.AreEqual(2, ones.TotalItems);
Assert.AreEqual(1, notOnes.TotalItems);
Assert.IsFalse(cats.Any());
}
public void Can_Add_Products_To_Collections()
{
//// Arrange
var products = MockProductDataMaker.MockProductCollectionForInserting(10).ToArray();
_productService.Save(products);
var collection1 = _entityCollectionService.CreateEntityCollectionWithKey(
EntityType.Product,
_providerKey,
"Product Collection1");
var provider1 = collection1.ResolveProvider <StaticProductCollectionProvider>();
Assert.NotNull(provider1);
Assert.AreEqual(typeof(StaticProductCollectionProvider), provider1.GetType());
var collection2 = _entityCollectionService.CreateEntityCollectionWithKey(
EntityType.Product,
_providerKey,
"Product Collection2");
var provider2 = collection2.ResolveProvider <StaticProductCollectionProvider>();
Assert.NotNull(provider2);
Assert.AreEqual(typeof(StaticProductCollectionProvider), provider2.GetType());
//// Act
var odd = false;
foreach (var p in products)
{
odd = !odd;
p.AddToCollection(collection1.Key);
if (odd)
{
p.AddToCollection(collection2.Key);
}
}
//// Assert
var c1Products = collection1.GetEntities <IProduct>().ToArray();
var c2Products = collection2.GetEntities <IProduct>().ToArray();
Assert.IsTrue(c1Products.Any());
Assert.IsTrue(c2Products.Any());
Assert.Greater(c1Products.Count(), c2Products.Count());
var p1 = c1Products.First();
Assert.IsTrue(p1.GetCollectionsContaining().Any());
}
public void Can_Find_ProductDisplay_Price_Property()
{
//// Arrange
var product = MockProductDataMaker.MockProductDisplayForInserting();
//// Act
var prop = product.GetType().GetProperty("Price", BindingFlags.Public | BindingFlags.Instance);
//// Assert
Assert.NotNull(prop);
}
public void Can_Save_A_Product()
{
//// Arrange
var product = MockProductDataMaker.MockProductForInserting();
//// Act
_productService.Save(product);
//// Assert
Assert.IsTrue(product.HasIdentity);
}
public void Can_Create_A_Product()
{
//// Arrage
var sku = MockDataMakerBase.MockSku();
var expected = MockProductDataMaker.MockProductForInserting("fake product", sku, 15.00m);
//// Act
var product = _productService.CreateProduct("fake product", sku, 15.00m);
//// Assert
Assert.AreEqual(expected.Name, product.Name);
}
public void Can_Add_A_Product_From_New_Product_Display()
{
//// Arrange
var display = MockProductDataMaker.MockProductDisplayForInserting();
//// Act
var product = AddProduct(display);
//// Assert
Assert.NotNull(product);
Assert.IsTrue(product.HasIdentity);
}
public void ProductIndex_Is_Updated_With_Product_Save()
{
//// Arrange
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
//// Act
_productService.Save(product);
//// Assert
Assert.IsTrue(_productSavedEventTriggered);
}
public void Init()
{
_customer = new AnonymousCustomer()
{
Key = Guid.NewGuid()
};
_itemCache = new ItemCache(_customer.Key, ItemCacheType.Basket)
{
Key = Guid.NewGuid()
};
_product = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
}
public void Can_Add_A_ProductVariant_To_A_Basket_And_IsEmpty_Returns_False()
{
//// Arrange
var basket = Basket.GetBasket(_customer, _itemCache);
var product = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
//// Act
basket.AddItem(product.GetProductVariantForPurchase());
//// Assert
Assert.IsTrue(basket.Items.Any());
Assert.IsFalse(basket.IsEmpty);
}
public void Init()
{
var warehouseService = PreTestDataWorker.WarehouseService;
_warehouse = warehouseService.GetDefaultWarehouse();
var productVariantService = PreTestDataWorker.ProductVariantService;
var productService = PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
product.Manufacturer = "Nike";
product.ManufacturerModelNumber = "N01-012021-A";
product.TrackInventory = true;
productService.Save(product);
_productKey = product.Key;
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
var variant = productVariantService.CreateProductVariantWithKey(product, attributes);
variant.AddToCatalogInventory(_warehouse.DefaultCatalog());
productVariantService.Save(variant);
_productVariantKey = variant.Key;
_examineId = ((ProductVariant)variant).ExamineId;
var provider = (ProductIndexer)ExamineManager.Instance.IndexProviderCollection["MerchelloProductIndexer"];
provider.AddProductToIndex(product);
}
public void Can_Save_Multiple_Products()
{
//// Arrange
var expected = 10;
var generated = MockProductDataMaker.MockProductCollectionForInserting(expected);
//// Act
_productService.Save(generated);
//// Assert
var retrieved = ((ProductService)_productService).GetAll();
Assert.IsTrue(retrieved.Any());
Assert.AreEqual(expected, retrieved.Count());
}
public void Can_RetrieveProductOptions_From_ProductInIndex()
{
//// Arrange
var merchello = new MerchelloHelper(MerchelloContext.Services);
var productVariantService = PreTestDataWorker.ProductVariantService;
var productService = PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
productService.Save(product);
var attributes = new ProductAttributeCollection()
{
product.ProductOptions.First(x => x.Name == "Color").Choices.First(x => x.Sku == "Blue"),
product.ProductOptions.First(x => x.Name == "Size").Choices.First(x => x.Sku == "XL")
};
productVariantService.CreateProductVariantWithKey(product, attributes);
_provider.AddProductToIndex(product);
//// Act
var productDisplay = merchello.Query.Product.GetByKey(product.Key);
//// Assert
Assert.NotNull(productDisplay);
Assert.IsTrue(productDisplay.ProductOptions.Any());
}
public void Can_Convert_A_LineItem_Of_Type_ItemCacheLineItem_To_A_InvoiceLineItem()
{
//// Arrange
var product = MockProductDataMaker.MockProductForInserting();
var extendedData = new ExtendedDataCollection();
extendedData.AddProductVariantValues(((Product)product).MasterVariant);
var itemCacheLineItem = new ItemCacheLineItem(LineItemType.Product, product.Name,
product.Sku, 2, 2 * product.Price, extendedData);
//// Act
var invoiceLineItem = itemCacheLineItem.AsLineItemOf <InvoiceLineItem>();
//// Assert
Assert.NotNull(invoiceLineItem);
Assert.AreEqual(Guid.Empty, invoiceLineItem.ContainerKey);
Assert.AreEqual(typeof(InvoiceLineItem), invoiceLineItem.GetType());
}
public void Can_Map_ProductDisplay_To_ProductVariantDisplay()
{
//// Arrange
var product = MockProductDataMaker.MockProductDisplayForInserting();
var key = Guid.NewGuid();
var variantKey = Guid.NewGuid();
product.Key = key;
product.ProductVariantKey = variantKey;
//// Act
var variant = AutoMapper.Mapper.Map <ProductVariantDisplay>(product);
//// Assert
Assert.NotNull(variant);
Assert.AreEqual(variantKey, variant.Key, "Variant key did not match");
Assert.AreEqual(key, variant.ProductKey, "Product key did not match");
}
public void Can_Find_An_Update_ProductDisplay_Price()
{
//// Arrange
var product = MockProductDataMaker.MockProductDisplayForInserting();
var oldPrice = product.Price;
//// Act
var propInfo = product.GetType().GetProperty("Price", BindingFlags.Public | BindingFlags.Instance);
if (propInfo != null && propInfo.CanRead)
{
propInfo.SetValue(product, 20M, null);
}
//// Assert
Console.WriteLine("Old price: {0}", oldPrice);
Assert.AreNotEqual(oldPrice, product.Price);
Assert.AreEqual(20M, product.Price);
}
public void GetProductByKeyReturnsCorrectItemFromRepository()
{
//// Arrange
Guid productKey = Guid.NewGuid();
ProductActual productActual = MockProductDataMaker.MockProductComplete(productKey) as ProductActual;
var MockProductService = new Mock <IProductService>();
MockProductService.Setup(cs => cs.GetByKey(productKey)).Returns(productActual);
MerchelloContext merchelloContext = GetMerchelloContext(MockProductService.Object);
ProductApiController ctrl = new ProductApiController(merchelloContext, tempUmbracoContext);
//// Act
var result = ctrl.GetProduct(productKey);
//// Assert
Assert.AreEqual(productActual, result);
}
public void Can_Update_Product_Options_Without_Breaking_Choices()
{
//// Arrange
var product = MockProductDataMaker.MockProductForInserting(weight: 10M);
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Color1", "Color1"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Color2", "Color2"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Size1", "Size1"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Size2", "Size2"));
//// Act
_productService.Save(product);
Assert.IsTrue(product.ProductVariants.Any());
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Color3", "Color3"));
_productService.Save(product);
Assert.IsTrue(product.ProductVariants.Any());
}
public override void FixtureSetup()
{
base.FixtureSetup();
var defaultWarehouse = DbPreTestDataWorker.WarehouseService.GetDefaultWarehouse();
var defaultCatalog = defaultWarehouse.WarehouseCatalogs.FirstOrDefault();
if (defaultCatalog == null)
{
Assert.Ignore("Default WarehouseCatalog is null");
}
DbPreTestDataWorker.DeleteAllShipCountries();
var uk = MerchelloContext.Current.Services.StoreSettingService.GetCountryByCode("GB");
var ukCountry = new ShipCountry(defaultCatalog.Key, uk);
((ServiceContext)MerchelloContext.Current.Services).ShipCountryService.Save(ukCountry);
this._settingService = MerchelloContext.Current.Services.StoreSettingService;
var setting = this._settingService.GetByKey(Core.Constants.StoreSetting.GlobalTaxationApplicationKey);
setting.Value = "Product";
this._settingService.Save(setting);
var taxProvider = MerchelloContext.Current.Gateways.Taxation.GetProviderByKey(Constants.ProviderKeys.Taxation.FixedRateTaxationProviderKey);
taxProvider.DeleteAllTaxMethods();
var gwTaxMethod = taxProvider.CreateTaxMethod("GB", 25);
gwTaxMethod.TaxMethod.ProductTaxMethod = true;
taxProvider.SaveTaxMethod(gwTaxMethod);
((TaxationContext)MerchelloContext.Current.Gateways.Taxation).ClearProductPricingMethod();
DbPreTestDataWorker.DeleteAllProducts();
var product = MockProductDataMaker.MockProductForInserting("Product", "PR", 16M);
product.SalePrice = 12M;
MerchelloContext.Current.Services.ProductService.Save(product);
_productKey = product.Key;
}
public void Can_Remove_Products_From_A_Collection()
{
//// Arrange
var products = MockProductDataMaker.MockProductCollectionForInserting(4).ToArray();
_productService.Save(products);
var collection1 = _entityCollectionService.CreateEntityCollectionWithKey(
EntityType.Product,
_providerKey,
"Product Collection1");
//// Act
foreach (var p in products)
{
p.AddToCollection(collection1.Key);
}
var provider = collection1.ResolveProvider <StaticProductCollectionProvider>();
Assert.NotNull(provider);
var cproducts = collection1.GetEntities <IProduct>().ToArray();
Assert.AreEqual(4, cproducts.Count());
var remove = cproducts.First();
var key = remove.Key;
remove.RemoveFromCollection(collection1);
//// Assert
var afterRemove = collection1.GetEntities <IProduct>().ToArray();
Assert.AreEqual(3, afterRemove.Count());
Assert.False(afterRemove.Any(x => x.Key == key));
Assert.IsFalse(collection1.Exists(remove));
Assert.IsFalse(remove.GetCollectionsContaining().Any());
Assert.IsFalse(collection1.ChildCollections().Any());
}
public void Sum_Of_Basket_Item_Quanities_Equals_Baskets_TotalQuantityCount()
{
//// Arrange
const int expected = 10;
var basket = Basket.GetBasket(_customer, _itemCache);
var product1 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
var product2 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
var product3 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
var product4 = MockProductDataMaker.MockProductComplete(Guid.NewGuid());
basket.AddItem(product1, product1.Name, 1);
basket.AddItem(product2, product2.Name, 2);
basket.AddItem(product3, product3.Name, 3);
basket.AddItem(product4, product4.Name, 4);
//// Act
var sum = basket.TotalQuantityCount;
//// Assert
Assert.AreEqual(expected, sum);
}
public void Can_Create_OrderDisplay_From_Index_Document()
{
//// Arrange
MockProductDataMaker.MockProductForInserting();
var invoice = MockInvoiceDataMaker.InvoiceForInserting(_address, 300);
invoice.Items.Add(new InvoiceLineItem(LineItemType.Product, "test", "test", 1, 100));
invoice.Items.Add(new InvoiceLineItem(LineItemType.Product, "test2", "test2", 2, 100));
PreTestDataWorker.InvoiceService.Save(invoice);
var order = invoice.PrepareOrder();
Core.MerchelloContext.Current.Services.OrderService.Save(order);
//// Act
var orderDisplay = OrderQuery.GetByKey(order.Key);
//// Assert
Assert.NotNull(orderDisplay);
// Fails becuase the products are not shippable and we made the change to automatically fulfill
//Assert.AreEqual(Constants.DefaultKeys.OrderStatus.NotFulfilled, orderDisplay.OrderStatus.Key);
Assert.AreEqual(order.Items.Count, orderDisplay.Items.Count());
}
public void Can_Retrieve_A_ProductVariant_From_The_Index()
{
//// Arrange
var merchello = new MerchelloHelper(MerchelloContext.Current.Services, false);
var productService = this.PreTestDataWorker.ProductService;
var product = MockProductDataMaker.MockProductCollectionForInserting(1).First();
product.ProductOptions.Add(new ProductOption("Color"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Blue", "Blue"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Red", "Red"));
product.ProductOptions.First(x => x.Name == "Color").Choices.Add(new ProductAttribute("Green", "Green"));
product.ProductOptions.Add(new ProductOption("Size"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Small", "Sm"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Medium", "Med"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("Large", "Lg"));
product.ProductOptions.First(x => x.Name == "Size").Choices.Add(new ProductAttribute("X-Large", "XL"));
product.Height = 11M;
product.Width = 11M;
product.Length = 11M;
product.CostOfGoods = 15M;
product.OnSale = true;
product.SalePrice = 18M;
productService.Save(product);
this._provider.AddProductToIndex(product);
Assert.IsTrue(product.ProductVariants.Any());
var variant = product.ProductVariants.First();
//// Act
var productVariantDisplay = merchello.Query.Product.GetProductVariantBySku(variant.Sku);
//// Assert
Assert.NotNull(productVariantDisplay);
Assert.AreEqual(variant.Key, productVariantDisplay.Key);
}
