public void Setup()
{
IOC.UnitTest();
_contentServiceMock = new IOCBuilder <IContentService>().SetupNewMock(); // IOC.ContentService.SetupNewMock();
_mockContentTypeService = new IOCBuilder <IContentTypeService>().SetupNewMock(); //IOC.ContentTypeService.SetupNewMock();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(995, 1);
productInfo.DocTypeAlias = "uwbsProductCustom";
productInfo.Title = "Nikes";
_orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo);
_orderInfo.OrderNumber = "2013001";
var contentType = new ContentType(1)
{
Id = 1234
};
_mockContentTypeService.Setup(m => m.GetContentType(Order.OrderRepositoryNodeAlias)).Returns(contentType);
_contentServiceMock.Setup(m => m.GetContentOfContentType(1234)).Returns(new List <IContent> {
new Content("", 1, contentType)
});
_contentServiceMock.Setup(m => m.GetChildren(It.IsAny <int>())).Returns(new List <IContent>());
_contentServiceMock.Setup(m => m.CreateContent("2013001", It.IsAny <IContent>(), It.IsAny <string>(), It.IsAny <int>())).Returns(new Content("2013001", 1, contentType));
_contentServiceMock.Setup(m => m.CreateContent("Nikes", It.IsAny <IContent>(), It.IsAny <string>(), It.IsAny <int>())).Returns(new Content("Nikes", 1, contentType));
}
public void DiscountAmountRegressionTest20140408()
{
IOC.IntegrationTest();
var product1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(400, 10);
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product1);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(10, DiscountOrderCondition.OnTheXthItem, 2);
//IOC.OrderDiscountRepository.SetupFake(discount.ToDiscountOrder());
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(order, discount);
var basket = new BasketOrderInfoAdaptor(order);
var basketLine = basket.OrderLines.Single();
Console.WriteLine(basketLine.Amount.Discount.WithVat.ToCurrencyString());
Console.WriteLine(basketLine.Amount.BeforeDiscount.WithVat.ToCurrencyString());
Console.WriteLine(basketLine.Amount.WithVat.ToCurrencyString());
var line = order.OrderLines.First();
Console.WriteLine(line.Amount.Discount.WithVat.ToCurrencyString());
Console.WriteLine(line.Amount.BeforeDiscount.WithVat.ToCurrencyString());
Console.WriteLine(line.Amount.WithVat.ToCurrencyString());
Assert.AreEqual(50, basketLine.Amount.Discount.WithVat.ValueInCents);
Assert.AreEqual(4000, basketLine.Amount.BeforeDiscount.WithVat.ValueInCents);
Assert.AreEqual(3950, basketLine.Amount.WithVat.ValueInCents);
Assert.AreEqual(50, line.Amount.Discount.WithVat.ValueInCents);
Assert.AreEqual(4000, line.Amount.BeforeDiscount.WithVat.ValueInCents);
Assert.AreEqual(3950, line.Amount.WithVat.ValueInCents);
}
public void MultipleAssertsIncludingVat()
{
IOC.SettingsService.InclVat();
var productInfo1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1100, 1, 10);
var productInfo2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(3850, 1, 10);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo1, productInfo2);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
Assert.NotNull(discount.Localization);
var d = orderInfo.DiscountAmountInCents;
var summedParts = orderInfo.OrderLines.Sum(l => l.GetAmount(false, true, true));
Assert.AreEqual((1000 + 3500), summedParts);
summedParts = orderInfo.OrderDiscountEffects.GetDiscountedPrice(summedParts, summedParts); // todo: add inclVat
Assert.AreEqual((1000 + 3500) / 2, summedParts);
Assert.AreEqual(2250, orderInfo.DiscountAmountWithoutVatInCents);
Assert.AreEqual(4950, orderInfo.OrderLines.Sum(orderline => orderline.AmountInCents));
Assert.AreEqual(50 + 175, orderInfo.TotalVatInCents);
Assert.AreEqual(2475, orderInfo.OrderTotalInCents);
Assert.AreEqual(2250, orderInfo.SubtotalInCents);
Assert.AreEqual(2250 + 225, orderInfo.GrandtotalInCents);
Assert.AreEqual(50 + 175, orderInfo.TotalVatInCents);
}
public void GrandTotalWithOrderDiscoun214t()
{
IOC.OrderService.Actual();
var productInfo = new ProductInfo {
Id = 1234, IsDiscounted = false, Vat = 0, OriginalPriceInCents = 1000, Ranges = new List <Range>()
};
IOC.CMSEntityRepository.SetupNewMock().Setup(m => m.GetByGlobalId(1234)).Returns(new UwbsNode {
Id = 1234, NodeTypeAlias = Product.NodeAlias
});
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(10, DiscountOrderCondition.None, 0);
discount.AffectedOrderlines = new List <int> {
1234
};
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
Assert.AreEqual(10, orderInfo.DiscountAmountInCents);
Assert.AreEqual(990, orderInfo.GrandtotalInCents);
Assert.AreEqual(990, orderInfo.OrderTotalInCents);
Assert.AreEqual(0, orderInfo.AverageOrderVatPercentage);
Assert.AreEqual(990, orderInfo.SubtotalInCents);
}
public void OrderWithManyItemsHadRelativelyLargeDeviationWhenCalculatingVatOverPartsInsteadOfOverTotal()
{
IOC.IntegrationTest();
IOC.SettingsService.InclVat();
IOC.VatCalculationStrategy.OverTotal();
var productInfo1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(7500, 2, 21m);
var productInfo2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(200, 25, 21m);
var productInfo3 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(200, 50, 21m);
var productInfo4 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(200, 50, 21m);
var productInfo5 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(200, 25, 21m);
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo1, productInfo2, productInfo3, productInfo4, productInfo5);
var directlyCalculatedVat = VatCalculator.VatAmountFromWithVat(45000, 21m);
Assert.AreEqual(7810, directlyCalculatedVat);
Assert.AreEqual(7810, order.VatTotalInCents);
Assert.AreEqual(45000, order.GrandtotalInCents);
Assert.AreEqual(45000 - 7810, order.SubtotalInCents);
Console.WriteLine(directlyCalculatedVat);
Console.WriteLine(order.VatTotalInCents);
Console.WriteLine(order.GrandtotalInCents);
// todo: this might be a concern:
// var orderNewDiscount = order.DiscountAmountWithVatInCents;
// Assert.AreEqual(x, orderNewDiscount); where x should not be 0 but orderNewDiscount is 0
}
public void PercentageDiscountExncludingVat()
{
IOC.IntegrationTest();
IOC.SettingsService.ExclVat();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1, 10);
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50);
IOC.OrderDiscountRepository.SetupFake(discount);
order.OrderDiscountsFactory = () => IO.Container.Resolve <IOrderDiscountService>().GetApplicableDiscountsForOrder(order, order.Localization).ToList();
order.ResetDiscounts();
Assert.AreEqual(1100, order.GetAmount(true, false, true));
Assert.AreEqual(1000, order.GetAmount(false, false, true));
Assert.AreEqual(550, order.GetAmount(true, true, true));
Assert.AreEqual(500, order.GetAmount(false, true, true));
var price = new SimplePrice(order, order.Localization);
Assert.AreEqual(1100, price.BeforeDiscount.WithVat.ValueInCents);
Assert.AreEqual(1000, price.BeforeDiscount.WithoutVat.ValueInCents);
Assert.AreEqual(100, price.BeforeDiscount.Vat.ValueInCents);
Assert.AreEqual(550, price.WithVat.ValueInCents);
Assert.AreEqual(500, price.WithoutVat.ValueInCents);
Assert.AreEqual(50, price.Vat.ValueInCents);
Assert.AreEqual(550, price.Discount.WithVat.ValueInCents);
Assert.AreEqual(500, price.Discount.WithoutVat.ValueInCents);
}
public void SomeRegressionTest()
{
var productInfo = new ProductInfo {
IsDiscounted = false, Vat = 6, OriginalPriceInCents = 1000, Ranges = new List <Range>()
};
productInfo.ProductVariants.Add(new ProductVariantInfo {
PriceInCents = -100
});
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
var line = orderInfo.OrderLines.Single();
var sellableUnit = orderInfo.OrderLines.Single().SellableUnits.Single();
Assert.AreEqual(900, sellableUnit.PriceInCents);
Assert.AreEqual(51, line.VatAmountInCents);
Assert.AreEqual(849, line.SubTotalInCents);
Assert.AreEqual(425, orderInfo.SubtotalInCents);
Assert.AreEqual(450, orderInfo.OrderTotalInCents);
Assert.AreEqual(6, orderInfo.AverageOrderVatPercentage);
Assert.AreEqual(450, orderInfo.GrandtotalInCents);
Assert.AreEqual(900, orderInfo.OrderLines.First().GrandTotalInCents);
Assert.AreEqual(900, productInfo.PriceWithVatInCents);
}
public void UpdatingAnOrderlineShouldBeReflectedInAmount()
{
IOC.UnitTest();
var orderUpdateService = IOC.OrderUpdatingService.Actual().Resolve();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
productInfo.Id = 5678;
productInfo.Vat = 10;
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var line = order.OrderLines.Single();
Assert.AreEqual(1000, order.GetAmount(true, false, false));
Assert.AreEqual(1000, line.GetAmount(true, false, false));
Assert.AreEqual(909, order.GetAmount(false, false, false));
var basket = Basket.CreateBasketFromOrderInfo(order);
Assert.AreEqual(1000, basket.ChargedOrderAmount.ValueInCents);
orderUpdateService.AddOrUpdateOrderLine(order, 0, 5678, "update", 2, new int[0]);
Assert.AreEqual(1, order.OrderLines.Count);
Assert.AreEqual(2, productInfo.Quantity);
Assert.AreEqual(2, line.SellableUnits.Count());
Assert.AreEqual(2000, line.GetAmount(true, false, false));
Assert.AreEqual(2000, order.GetAmount(true, false, false));
basket = Basket.CreateBasketFromOrderInfo(order);
Assert.AreEqual(2000, basket.ChargedOrderAmount.ValueInCents);
}
public void SingleLineTwoProductsShouldGiveEqual()
{
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 2, 19);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo);
Assert.AreEqual(19, orderInfo.AverageOrderVatPercentage);
}
public void OrderWithTwoLinesAndDiscount_ShouldGiveVatAmountOfProductMinusOrderDiscount(bool includingVat, decimal vat, int numberOfItemsInOrderLine)
{
if (includingVat)
{
IOC.SettingsService.InclVat();
}
else
{
IOC.SettingsService.ExclVat();
}
var productInfo1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, numberOfItemsInOrderLine, vat);
var productInfo2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(3500, numberOfItemsInOrderLine, vat);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo1, productInfo2);
var line1 = orderInfo.OrderLines.First();
var line2 = orderInfo.OrderLines.Skip(1).First();
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
var totalOrderDiscount = includingVat ? orderInfo.DiscountAmountWithVatInCents : orderInfo.DiscountAmountWithoutVatInCents;
Assert.AreEqual(includingVat, orderInfo.PricesAreIncludingVAT);
Assert.AreEqual(vat, line1.Vat);
Assert.AreEqual(2250 * numberOfItemsInOrderLine, totalOrderDiscount);
var expected = includingVat || vat < 1 ? 4500 : 4950;
Assert.AreEqual(expected * numberOfItemsInOrderLine, line1.Amount.WithVat.ValueInCents + line2.Amount.WithVat.ValueInCents);
}
public void CombinedTooLargeAmountAndPercentage()
{
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1));
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(1234, DiscountOrderCondition.None, 0), DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50));
Assert.AreEqual(1000, orderInfo.DiscountAmountInCents);
}
public void TestAddOrUpdateOrderLine()
{
IOC.UnitTest();
var productDiscount = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(36);
productDiscount.RangesString = new List <Range> {
new Range {
From = 1, To = 20, PriceInCents = 10000
}
}.ToRangesString();
var product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(5000, 5, productDiscount);
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product);
Assert.IsTrue(productDiscount.Ranges.Any());
Assert.AreEqual(10000, productDiscount.RangedDiscountValue(15));
Assert.AreEqual(100, product.DiscountPercentage);
Assert.AreEqual(0, order.OrderLineTotalInCents);
IOC.ProductService.SetupNewMock().Setup(m => m.GetById(1234, It.IsAny <ILocalization>(), It.IsAny <bool>())).Returns(new Product {
Id = 1234, UseVariantStock = true
});
var orderUpdatingService = IOC.OrderUpdatingService.Actual().Resolve();
// todo: actually make the update productinfo functionality testable..
//orderUpdatingService.AddOrUpdateOrderLine(order, 0, 1234, "update", 15, new List<int>());
}
public void BasicTests()
{
IOC.UnitTest();
IOC.SettingsService.ExclVat();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
productInfo.Id = 5678;
productInfo.Vat = 10;
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var line = order.OrderLines.Single();
Assert.AreEqual(1000, order.GetAmount(false, false, false));
Assert.AreEqual(1000, line.GetAmount(false, false, false));
Assert.AreEqual(1100, order.GetAmount(true, false, false));
Assert.AreEqual(1100, line.GetAmount(true, false, false));
Assert.AreEqual(1100, order.ChargedAmountInCents);
Assert.AreEqual(1100, order.GrandtotalInCents);
Assert.AreEqual(1000, order.SubtotalInCents);
var basket = Basket.CreateBasketFromOrderInfo(order);
Assert.AreEqual(1100, basket.ChargedOrderAmount.ValueInCents);
}
public void OrderWithOneLine_ShouldGiveVatAmountOfProduct(bool includingVat, decimal vat, int numberOfItemsInOrderLine)
{
IOC.SettingsService.ExclVat();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, numberOfItemsInOrderLine, vat);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo);
Assert.AreEqual(productInfo.VatAmountInCents * numberOfItemsInOrderLine, orderInfo.TotalVatInCents);
}
public ProductInfo CreateProductInfoByProductId(int productId, OrderInfo order, ILocalization localization, int itemCount)
{
if (productId == ProductId1)
{
return(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(995, 1));
}
return(null);
}
public void TestSerialization()
{
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1995, 2));
orderInfo.ShippingProviderAmountInCents = 650;
Assert.NotNull(orderInfo.ChargedShippingCosts);
Console.WriteLine(DomainHelper.SerializeObjectToXmlString(orderInfo));
}
public void Setup()
{
IOC.IntegrationTest();
_orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1));
_orderDiscount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(195, DiscountOrderCondition.None, 0);
}
public void TwoLinesThreeProductsDifferentVatShouldGiveWeightedAverageWithVatExempt()
{
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 2, 19);
var productInfo2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1, 0);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo, productInfo2);
Assert.AreEqual((2m * 19) / 3, orderInfo.AverageOrderVatPercentage);
}
public void TwoLinesTwoProductsDifferentVatShouldGiveAverage()
{
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(100000, 10, 19);
var productInfo2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(100000, 10, 6);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo, productInfo2);
Assert.AreEqual(12.5, orderInfo.AverageOrderVatPercentage);
}
public void Setup()
{
IOC.UnitTest();
_discountCalculationService = IOC.DiscountCalculationService.Actual().Resolve();
_product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
_product.Tags = new [] { "schoen" };
_order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(_product);
}
public void ShippingProviderShouldNotBeApplicableWhenEndRangeEqualsOrderlinesAmount_WhenExcludingVat()
{
IOC.SettingsService.ExclVat();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo);
var provider = DefaultFactoriesAndSharedFunctionality.CreateShippingProvider(0, 1000, ShippingRangeType.OrderAmount);
Assert.IsFalse(provider.IsApplicableToOrder(orderInfo));
}
public void OrderHavingAConfirmDate_ShouldRenderOrderDate()
{
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo();
orderInfo.ConfirmDate = DateTime.Now;
var xml = DomainHelper.SerializeObjectToXmlString(orderInfo);
Assert.That(xml.Contains("<OrderDate>"));
Assert.Greater(xml.IndexOf("</OrderDate>") - xml.IndexOf("<OrderDate>"), 11);
}
public void DiscountAmountForOrder_TagsNotMatching_GivesZeroDiscount()
{
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50);
discount.AffectedProductTags = new[] { "jas" };
var amount = _discountCalculationService.DiscountAmountForOrder(discount, _order);
Assert.AreEqual(0, amount);
}
public void OrderInfoWithApplicableDiscount_ShouldReturnInformationOnThatDiscount()
{
var product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(10);
IOC.OrderDiscountRepository.SetupFake(new IOrderDiscount[] { discount.ToDiscountOrder() });
Assert.AreEqual(1, orderInfo.AppliedDiscountsInformation.Count);
}
public void DiscountAmountForOrderOnOrderWithTwoOrderLinesAndApplicableNewPriceDiscountWithOnTheXthItemCondition_ShouldGiveCheapestProductPriceTotalMinusTheDiscountAmount()
{
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1995, 1), DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1899, 1));
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithNewPrice(1000, DiscountOrderCondition.OnTheXthItem, 2);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
var actual = _discountCalculationService.DiscountAmountForOrder(discount, orderInfo);
Assert.AreEqual(1899 - 1000, actual);
}
public void DiscountAmountForOrderOnOrderWithTwoLinesTwoProductsAndApplicableNewPriceDiscountWithPerSetOfItemsCondition_ShouldGiveOrderLineTotalMinusTwoTimesTheDiscountAmount()
{
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1995, 2), DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1899, 2));
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithNewPrice(1000, DiscountOrderCondition.PerSetOfXItems, 2);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
var actual = _discountCalculationService.DiscountAmountForOrder(discount, orderInfo);
Assert.AreEqual(orderInfo.OrderLineTotalInCents - 2000, actual);
}
public void DiscountAmountForOrderOnOrderWithSingleProductAndApplicableNewPriceDiscount_ShouldGiveProductPriceMinusDiscountAmount()
{
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1995, 1));
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithNewPrice(1000);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
var actual = _discountCalculationService.DiscountAmountForOrder(discount, orderInfo);
Assert.AreEqual(1995 - 1000, actual);
}
public void Setup()
{
IOC.UnitTest();
_stockServiceMock = IOC.StockService.SetupNewMock();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(12990, 1);
productInfo.Id = TestProductService.ProductId1;
_order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
_order.StoreInfo.Alias = StoreHelper.GetCurrentStore().Alias;
}
public void ThatPercentDiscountIsAppliedToCorrectNumberOfItemsFixedDiscount(int setSize, int itemCount, int expectedNumberOfDiscounts)
{
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, itemCount);
var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(50, DiscountOrderCondition.PerSetOfXItems, setSize);
DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount);
Assert.AreEqual(itemCount * 1000 - expectedNumberOfDiscounts * 50, orderInfo.OrderTotalInCents);
}
public void PercentageProductDiscountOnProductWithVariant_ShouldGiveDiscountThatTakesVariantEffectIntoAccount()
{
IOC.UnitTest();
var discount = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(50);
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1, discount);
var variant = DefaultFactoriesAndSharedFunctionality.CreateProductVariantInfo(-200);
DefaultFactoriesAndSharedFunctionality.SetVariantsOnProductInfo(productInfo, variant);
Assert.AreEqual(400, productInfo.PriceInCents);
}
