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 CategoryNiceUrl_NoStorePickerSet_ReturnsSlashCategoryUrl() { IOC.IntegrationTest(); IOC.CategoryService.UseType <FakeCategoryService>(); IOC.StoreService.Actual(); IOC.CMSEntityRepository.Mock(out _cmsEntityRepositoryMock); _cmsEntityRepositoryMock.Setup(m => m.GetByGlobalId(1)).Returns(new UwbsNode { NodeTypeAlias = "uwbsCategory" }); _cmsEntityRepositoryMock.Setup(m => m.GetObjectsByAliasUncached <Store>(Store.NodeAlias, It.IsAny <ILocalization>(), It.IsAny <int>())).Returns(new List <Store> { StoreHelper.GetCurrentStore() }); Mock <ICategoryService> catalogServiceMock; IOC.CategoryService.Mock(out catalogServiceMock); var category = new Category { UrlName = "shoes", ParentId = -1, SubCategories = Enumerable.Empty <Category>() }; catalogServiceMock.Setup(m => m.GetById(1, It.IsAny <ILocalization>(), It.IsAny <bool>())).Returns(category); catalogServiceMock.Setup(m => m.Localize(category, It.IsAny <ILocalization>())).Returns(category); // bah bah uWebshop.Domain.Core.Initialize.InitializeServiceLocators(IOC.CurrentContainer); // todo hackish, find a better solution Assert.AreEqual(IOC.StoreService.Resolve(), StoreHelper.StoreService); var actual = StoreHelper.GetNiceUrl(1); Assert.AreEqual("/shoes", actual); }
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 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 Setup() { IOC.IntegrationTest(); _orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1)); _orderDiscount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(195, DiscountOrderCondition.None, 0); }
public void Setup() { IOC.IntegrationTest(); _product = new Product(); _product.Localization = StoreHelper.CurrentLocalization; _product.Id = 1; _product.Ranges = new List <Range>(); _product.PricesIncludingVat = false; _product.ProductDiscount = null; }
public void Setup() { IOC.IntegrationTest(); // at some point we will need to specify here that we want to use the 'storeUrl localization' module and 'catalog recursive categories url' (oid) module _product = new Product { UrlName = "prod", Categories = new ICategory[] { new StubCategory { UrlName = "cat2", ParentCategory = new StubCategory { UrlName = "cat1" } } } }; }
public void ProductInfo_PriceCalculationRegressionTest() { IOC.IntegrationTest(); var product = new ProductInfo { OriginalPriceInCents = 990000, DiscountAmountInCents = 990000 - 100000 }; var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product); Assert.AreEqual(990000, product.Price.BeforeDiscount.ValueInCents()); Assert.AreEqual(100000, product.Price.ValueInCents()); Assert.AreEqual(890000, product.Price.Discount.WithVat.ValueInCents); }
public void AreBothCategoryCachesCleared_FunctionalDebugCache20150316() { IOC.IntegrationTest(); IOC.CategoryService.Actual(); var service = IOC.ApplicationCacheManagingService.Actual().Resolve(); service.Initialize(); service.ReloadEntityWithGlobalId(1, string.Empty); Thread.Sleep(10500); }
public void DiscountAmount() { IOC.IntegrationTest(); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(5995, 1, 19, new DiscountProduct { DiscountType = DiscountType.Amount, DiscountValue = 2000 })); var basket = Basket.CreateBasketFromOrderInfo(order); Assert.AreEqual(3995, order.OrderLineTotalInCents); Assert.AreEqual(3995, basket.OrderLineTotal.ValueInCents()); Assert.AreEqual(3995, basket.OrderLineTotal.BeforeDiscount.ValueInCents()); Assert.AreEqual(0, basket.OrderLineTotal.Discount.ValueInCents()); }
public void Setup() { IOC.IntegrationTest(); IOC.StoreService.Actual(); _category = new Category { UrlName = "cat", Id = 1234, ParentId = 0, Localization = StoreHelper.CurrentLocalization }; Assert.IsTrue(_category.Localization.Equals(StoreHelper.CurrentLocalization)); var setupNewMock = IOC.CategoryService.SetupNewMock(); setupNewMock.Setup(m => m.GetById(1234, It.IsAny <ILocalization>(), It.IsAny <bool>())).Returns(_category); setupNewMock.Setup(m => m.Localize(_category, It.IsAny <ILocalization>())).Returns(_category); uWebshop.Domain.Core.Initialize.InitializeServiceLocators(IOC.CurrentContainer); // hackish, find a better solution }
public void DiscountAmountCalculationRegressionTest() { IOC.IntegrationTest(); _source = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1)); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50); DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(_source, discount); var price = Price.CreateDiscountedRanged(BasketTotalBeforeDiscount(), null, _source.PricesAreIncludingVAT, _source.AverageOrderVatPercentage, null, i => i - _source.DiscountAmountInCents, _source.Localization); Assert.AreEqual(500, IO.Container.Resolve <IDiscountCalculationService>().DiscountAmountForOrder(discount, _source)); Assert.AreEqual(500, _source.DiscountAmountInCents); Assert.AreEqual(500, price.WithVat.ValueInCents); Assert.AreEqual(500, price.Discount.WithVat.ValueInCents); }
public void Setup() { IOC.IntegrationTest(); _product = new Product { OriginalPriceInCents = 1000, Id = 12234, Ranges = new List <Range>(), Vat = 21m }; _variant = new ProductVariant { OriginalPriceInCents = 100 }; _product.VariantGroups = new List <IProductVariantGroup> { new ProductVariantGroup("", new List <ProductVariant> { _variant }, 1) }; _variant.Product = _product; }
public void DiscountAmountRegressionTest20140321() { IOC.IntegrationTest(); IOC.VatCalculationStrategy.OverParts(); var product1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(10, 5); var product2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(750, 3); //var product3 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1, 5, 19); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product1, product2); //var basket = Basket.CreateBasketFromOrderInfo(order); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithNewPrice(0); IOC.OrderDiscountRepository.SetupFake(discount.ToDiscountOrder()); DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(order, discount); //Assert.AreEqual(2255, basket.OrderAmount.Discount.WithVat.ValueInCents); //Assert.AreEqual(0, basket.OrderAmount.WithVat.ValueInCents); //var discountAmount = IOC.DiscountCalculationService.Actual().Resolve().DiscountAmountForOrder(discount, order, true); //Assert.AreEqual(2255, discountAmount); var line = order.OrderLines.First(); var unit = line.SellableUnits.First(); Assert.AreEqual(10, unit.PriceInCents); Assert.AreEqual(0, unit.DiscountedPrice); var newDiscount = line.SellableUnits.Select(su => su.PriceInCents - su.DiscountedPrice).Sum(); Assert.AreEqual(50, newDiscount); //OrderLineTotalWithVatInCents, GetAmount(true, false, true) - GetAmount(true, true, true) Assert.AreEqual(0, order.OrderLineTotalWithVatInCents); var orderNewDiscount = order.DiscountAmountWithVatInCents; Assert.AreEqual(2300, orderNewDiscount); var orderDiscount = order.DiscountAmountInCents; Assert.AreEqual(2300, orderDiscount); Assert.AreEqual(50, line.DiscountInCents); }
public void DiscountAmountRegressionTest20140627() { IOC.IntegrationTest(); IOC.SettingsService.ExclVat(); var product1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(4000, 1, 0); var product2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1800, 1, 20); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product1, product2); Assert.AreEqual(5800, order.SubtotalInCents); Assert.AreEqual(6160, order.GrandtotalInCents); Assert.AreEqual(360, order.VatTotalInCents); var basket = Basket.CreateBasketFromOrderInfo(order); Assert.AreEqual(5800, basket.OrderAmount.WithoutVat.ValueInCents); Assert.AreEqual(6160, basket.OrderAmount.WithVat.ValueInCents); Assert.AreEqual(360, basket.OrderAmount.Vat.ValueInCents); }
public void AmountDiscountIncludingVat() { IOC.IntegrationTest(); var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1, 10); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(500, DiscountOrderCondition.None, 0); IOC.OrderDiscountRepository.SetupFake(discount); order.OrderDiscountsFactory = () => IO.Container.Resolve <IOrderDiscountService>().GetApplicableDiscountsForOrder(order, order.Localization).ToList(); order.ResetDiscounts(); var absoluteDiscountAmount = 500; var AverageOrderVatPercentage = 10m; var vatAmountFromWithVat = VatCalculator.VatAmountFromWithVat(absoluteDiscountAmount, AverageOrderVatPercentage); //var vatAmountFromWithoutVat = VatCalculator.VatAmountFromWithoutVat(absoluteDiscountAmount, AverageOrderVatPercentage); Assert.AreEqual(45, vatAmountFromWithVat); // berekende discount vat = 45,45454545.. // correct zou zijn 500 - 454 = 46 (zie hieronder) // full amount: 909 // discounted amount: 455 // discount: 909 - 455 = 454 // 'discount vat': 500 - 454 = 46 Assert.AreEqual(1000, order.GetAmount(true, false, true)); Assert.AreEqual(909, order.GetAmount(false, false, true)); Assert.AreEqual(500, order.GetAmount(true, true, true)); Assert.AreEqual(455, order.GetAmount(false, true, true)); var price = new SimplePrice(order, order.Localization); Assert.AreEqual(1000, price.BeforeDiscount.WithVat.ValueInCents); Assert.AreEqual(909, price.BeforeDiscount.WithoutVat.ValueInCents); Assert.AreEqual(91, price.BeforeDiscount.Vat.ValueInCents); Assert.AreEqual(500, price.WithVat.ValueInCents); Assert.AreEqual(455, price.WithoutVat.ValueInCents); Assert.AreEqual(45, price.Vat.ValueInCents); Assert.AreEqual(500, price.Discount.WithVat.ValueInCents); Assert.AreEqual(454, price.Discount.WithoutVat.ValueInCents); }
public void bla1() { IOC.IntegrationTest(); var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(12990, 1); productInfo.Id = TestProductService.ProductId1; var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(100); discount.CouponCode = "coup"; IO.Container.Resolve <IOrderService>().UseStoredDiscounts(orderInfo, new List <IOrderDiscount> { new OrderDiscount(StoreHelper.CurrentLocalization, discount, orderInfo) }); orderInfo.SetCouponCode("coup"); Assert.AreEqual(12990, orderInfo.DiscountAmountInCents); Assert.AreEqual(12990, orderInfo.DiscountAmountWithVatInCents); Assert.AreEqual(0, orderInfo.OrderTotalInCents); }
public void bla() { IOC.IntegrationTest(); IOC.CouponCodeService.SetupNewMock().Setup(m => m.GetAllForDiscount(1234)).Returns(new List <Coupon> { new Coupon(1234, "code", 7), }); var a = IOC.DiscountCalculationService.Actual().Resolve(); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithAmount(1000, DiscountOrderCondition.None, 0); discount.Id = 1234; DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(null, discount); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(2199, 2)); order.CouponCodesData.Add("code"); var actual = a.DiscountAmountForOrder(discount, order); Assert.AreEqual(1000, actual); Assert.NotNull(order.OrderDiscountsFactory); var discountlist = IOC.OrderDiscountService.Resolve().GetApplicableDiscountsForOrder(order, order.Localization); Assert.AreEqual(1, discountlist.Count()); var d = order.Discounts.FirstOrDefault(); Assert.NotNull(d); var basket = Basket.CreateBasketFromOrderInfo(order); var disc = basket.Discounts.FirstOrDefault(); Assert.NotNull(disc); Assert.AreEqual("code", disc.CouponCode); }
public void Test() { IOC.IntegrationTest(); IOC.SettingsService.ExclVat(); IOC.VatCalculationStrategy.OverParts(); var productDiscountPercentage = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(17); var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(2456, 5, 20m, productDiscountPercentage); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo); var line = order.OrderLines.Single(); Assert.AreEqual(2038, productInfo.PriceInCents); Assert.AreEqual(2446, productInfo.PriceWithVatInCents); Assert.AreEqual(408, productInfo.VatAmountInCents); Assert.AreEqual(2446 * 5, line.AmountInCents); Assert.AreEqual(2446 * 5, line.GrandTotalInCents); Assert.AreEqual(2038 * 5, line.SubTotalInCents); Assert.AreEqual(408 * 5, line.VatAmountInCents); Assert.AreEqual(408 * 5, line.OrderLineVatAmountAfterOrderDiscountInCents); Assert.AreEqual(408 * 5, order.VatTotalInCents); Assert.AreEqual(2446 * 5, order.GrandtotalInCents); Assert.AreEqual(2038 * 5, order.SubtotalInCents); }
public void TestDiscount() { IOC.IntegrationTest(); IOC.SettingsService.ExclVat(); IOC.VatCalculationStrategy.OverParts(); var productDiscountPercentage = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(17); var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(2456, 5, 20m, productDiscountPercentage); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(50); DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(order, discount); var line = order.OrderLines.Single(); Assert.AreEqual(2038, productInfo.PriceInCents); Assert.AreEqual(2446, productInfo.PriceWithVatInCents); Assert.AreEqual(408, productInfo.VatAmountInCents); Assert.AreEqual(2446 * 5, line.AmountInCents); Assert.AreEqual(2446 * 5, line.GrandTotalInCents); Assert.AreEqual(2038 * 5, line.SubTotalInCents); Assert.AreEqual(408 * 5, line.VatAmountInCents); // todo: commented lines need to be adjusted for discount on order lvl //Assert.AreEqual(2038 / 2, productInfo.OrderPriceInCents); //Assert.AreEqual(2446 / 2, productInfo.OrderPriceWithVatInCents); //Assert.AreEqual(408 / 2, productInfo.OrderVatAmountInCents); //Assert.AreEqual(2038 * 5 / 2, line.OrderAmountInCents); //Assert.AreEqual(2446 * 5 / 2, line.OrderAmountWithVatInCents); //Assert.AreEqual(2038 * 5 / 2, line.OrderAmountWithoutInCents); //Assert.AreEqual(408 * 5 / 2, line.OrderVatAmountInCents); //Assert.AreEqual(408 * 5 / 2, line.OrderLineVatAmountAfterOrderDiscountInCents); Assert.AreEqual(408 * 5 / 2, order.VatTotalInCents); Assert.AreEqual(2446 * 5 / 2, order.GrandtotalInCents); Assert.AreEqual(2038 * 5 / 2, order.SubtotalInCents); }
public void orderdiscount_with_coupon_and_hundred_percent_had_eror_in_DiscountamountForOrder() { IOC.IntegrationTest(); var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(12990, 1); productInfo.Id = TestProductService.ProductId1; var orderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo); var discount1 = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(100); discount1.CouponCode = "coup"; IOC.OrderDiscountRepository.SetupFake(discount1.ToDiscountOrder()); DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(orderInfo, discount1); orderInfo.SetCouponCode("coup"); Assert.AreEqual(12990, orderInfo.OrderLines.Sum(orderline => orderline.AmountInCents)); Assert.AreEqual(12990, orderInfo.Discounts.Sum(d => IO.Container.Resolve <IDiscountCalculationService>().DiscountAmountForOrder(d, orderInfo))); Assert.AreEqual(12990, orderInfo.DiscountAmountInCents); Assert.AreEqual(0, orderInfo.OrderTotalInCents); Assert.NotNull(orderInfo.OrderDiscountsFactory); var orderService = IO.Container.Resolve <IOrderService>(); var discountRepository = IO.Container.Resolve <IOrderDiscountRepository>(); var orderDiscounts = discountRepository.GetAll(orderInfo.Localization); Assert.IsTrue(orderDiscounts.Any()); var orderLinesAmount = orderInfo.OrderLines.Sum(orderline => orderline.GrandTotalInCents); Assert.AreEqual(12990, orderLinesAmount); var discount = orderDiscounts.First(); Assert.IsTrue(!discount.Disabled && orderLinesAmount >= discount.MinimumOrderAmount.ValueInCents() && (!discount.RequiredItemIds.Any() || orderService.OrderContainsItem(orderInfo, discount.RequiredItemIds)) && (!discount.CounterEnabled || discount.Counter > 0)); Assert.IsFalse(!string.IsNullOrEmpty(discount.CouponCode) && !orderInfo.CouponCodes.Contains(discount.CouponCode)); var discountService = IO.Container.Resolve <IOrderDiscountService>(); //var orderDiscounts = GetAll(localization); //var orderLinesAmount = order.OrderLines.Sum(orderline => orderline.AmountInCents); //return orderDiscounts.Where(discount => !discount.Disabled && orderLinesAmount >= discount.MinimumOrderAmount.ValueInCents && (!discount.RequiredItemIds.Any() // || _orderService.OrderContainsItem(order, discount.RequiredItemIds)) && (!discount.CounterEnabled || discount.Counter > 0)).HasDiscountForOrder(order).ToList(); Assert.IsTrue(discountService.GetAll(orderInfo.Localization).Any()); Assert.AreEqual(12990, orderInfo.OrderLines.Sum(orderline => orderline.AmountInCents)); var dit = discountService.GetAll(orderInfo.Localization).First(); Assert.IsTrue(!dit.Disabled); Assert.AreEqual(0, dit.MinimumOrderAmount.ValueInCents()); Assert.IsFalse(dit.RequiredItemIds.Any()); Assert.IsFalse(dit.CounterEnabled); Assert.IsTrue(IO.Container.Resolve <IDiscountCalculationService>().DiscountAmountForOrder(dit, orderInfo) > 0); orderInfo.ResetDiscounts(); Assert.IsTrue(discountService.GetApplicableDiscountsForOrder(orderInfo, orderInfo.Localization).Any()); Assert.IsTrue(orderInfo.OrderDiscountsFactory().Any()); }
public void DiscountAmountRegressionTest20140116() { IOC.IntegrationTest(); var product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(6000, 1, 19, new DiscountProduct { DiscountType = DiscountType.Amount, DiscountValue = 2000 }); var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product); var oldLine = order.OrderLines.Single(); var basket = Basket.CreateBasketFromOrderInfo(order); Assert.AreEqual(4000, order.OrderLineTotalInCents); Assert.AreEqual(4000, basket.OrderAmount.ValueInCents()); Assert.AreEqual(4000, basket.OrderAmount.BeforeDiscount.ValueInCents()); Assert.AreEqual(0, basket.OrderAmount.Discount.ValueInCents()); IOC.IntegrationTest(); var discount = DefaultFactoriesAndSharedFunctionality.CreateDefaultOrderDiscountWithPercentage(25); IOC.OrderDiscountRepository.SetupFake(discount); //DefaultFactoriesAndSharedFunctionality.SetDiscountsOnOrderInfo(order, discount); order.OrderDiscountsFactory = () => IO.Container.Resolve <IOrderDiscountService>().GetApplicableDiscountsForOrder(order, order.Localization).ToList(); order.ResetDiscounts(); Assert.AreEqual(4000, order.OrderLineTotalInCents); Assert.AreEqual(4000, order.OrderLines.Single().ProductInfo.PriceInCents); Assert.AreEqual(1000, IOC.DiscountCalculationService.Actual().Resolve().DiscountAmountForOrder(discount, order)); order.ResetDiscounts(); Assert.AreEqual(1000, order.DiscountAmountInCents); Assert.AreEqual(4000, order.OrderLineTotalInCents); Assert.AreEqual(3000, basket.OrderAmount.ValueInCents()); Assert.AreEqual(4000, basket.OrderAmount.BeforeDiscount.ValueInCents()); Assert.AreEqual(4000, basket.OrderAmount.BeforeDiscount.WithVat.ValueInCents); Assert.AreEqual(3361, basket.OrderAmount.BeforeDiscount.WithoutVat.ValueInCents); Assert.AreEqual(4000, oldLine.Amount.ValueInCents()); Assert.AreEqual(4000, oldLine.Amount.BeforeDiscount.ValueInCents()); Assert.AreEqual(0, oldLine.Amount.Discount.WithVat.ValueInCents); Assert.AreEqual(0, oldLine.Amount.Discount.ValueInCents()); var price = new SummedPrice(new[] { oldLine.Amount }, true, 19, StoreHelper.CurrentLocalization, IO.Container.Resolve <IVatCalculationStrategy>()); Assert.AreEqual(4000, price.ValueInCents); price = new SummedPrice(new[] { oldLine.Amount }, true, 19, StoreHelper.CurrentLocalization, IO.Container.Resolve <IVatCalculationStrategy>()); Assert.AreEqual(4000, price.BeforeDiscount.ValueInCents()); price = new SummedPrice(new[] { oldLine.Amount }, true, 19, StoreHelper.CurrentLocalization, IO.Container.Resolve <IVatCalculationStrategy>()); Assert.AreEqual(0, price.Discount.ValueInCents()); var line = basket.OrderLines.Single(); Assert.AreEqual(4000, line.Amount.ValueInCents()); Assert.AreEqual(4000, line.Amount.BeforeDiscount.ValueInCents()); Assert.AreEqual(0, line.Amount.Discount.ValueInCents()); Assert.AreEqual(1000, basket.OrderAmount.Discount.ValueInCents()); Assert.AreEqual(840, basket.OrderAmount.Discount.WithoutVat.ValueInCents); Assert.AreEqual(1000, basket.OrderAmount.Discount.WithVat.ValueInCents); }
public void Setup() { IOC.IntegrationTest(); IOC.DiscountCalculationService.Actual(); }
public void Setup() { IOC.IntegrationTest(); }
public void Setup() { IOC.IntegrationTest(); IOC.UrlService.Mock(out _urlService); _product = TestProductService.Product1; }