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;
}
