public void WHEN_cart_has_no_taxes_SHOULD_return_vm_with_empty_taxes()
        {
            //Arrange
            UseCountryServiceMock();

            var p = new CreateCartViewModelParam()
            {
                Cart             = FakeCartFactory.CreateEmptyCartWithEmptyShipment(),
                CultureInfo      = CultureInfo.InvariantCulture,
                BaseUrl          = GetRandom.String(32),
                ProductImageInfo = new ProductImageInfo()
                {
                    ImageUrls = new List <ProductMainImage>()
                }
            };

            var sut = Container.CreateInstance <CartViewModelFactory>();

            //Act
            var vm = sut.CreateCartViewModel(p);

            //Assert
            vm.Should().NotBeNull();
            vm.OrderSummary.Taxes.Should().BeEmpty();
        }
Exemplo n.º 2
0
        public void WHEN_cart_has_taxes_SHOULD_map_first_shipment_taxes()
        {
            //Arrange
            var culture = CultureInfo.InvariantCulture;

            var taxes = new List <Tax>()
            {
                FakeCartFactory.CreateTax(_taxes, culture),
                FakeCartFactory.CreateTax(_taxes, culture),
                FakeCartFactory.CreateTax(_taxes, culture)
            };

            var sut = Container.CreateInstance <TaxViewModelFactory>();

            //Act
            var vm = sut.CreateTaxViewModels(taxes, culture);

            //Assert
            vm.Should().NotBeNull();
            vm.Should().HaveSameCount(_taxes, "only taxes from first shipment are considered");

            for (int i = 0; i < vm.ToList().Count; i++)
            {
                var tax          = vm.ToList()[i];
                var taxReference = _taxes[i];

                tax.Should().NotBeNull();
                tax.DisplayName.Should().Be(taxReference.DisplayName.GetLocalizedValue(culture.Name));
                tax.TaxTotal.Should().HaveValue("TaxTotal was defined in tax");
            }
        }
        public void WHEN_cart_has_discounts_SHOULD_map_first_shipment_distinct_non_lineitem_discounts()
        {
            var randomReward = FakeCartFactory.CreateRandomReward(_rewards, RewardLevel.FulfillmentMethod);

            //Arrange
            var rewards = new List <Reward>()
            {
                randomReward,
                FakeCartFactory.CreateRandomReward(_rewards, RewardLevel.FulfillmentMethod),
                FakeCartFactory.CreateRandomReward(null, RewardLevel.LineItem),
                FakeCartFactory.CreateRandomReward(_rewards, RewardLevel.FulfillmentMethod),
                randomReward
            };

            var sut = Container.CreateInstance <RewardViewModelFactory>();

            //Act
            var vm = sut.CreateViewModel(rewards, CultureInfo.InvariantCulture, RewardLevel.FulfillmentMethod, RewardLevel.Shipment);

            //Assert
            vm.Should().NotBeNullOrEmpty();
            vm.Should().HaveSameCount(_rewards);

            for (int i = 0; i < vm.ToList().Count; i++)
            {
                var d = vm.ToList()[i];

                d.Should().NotBeNull();
                d.Description.Should().Be(_rewards[i].Description);
            }
        }
        public void WHEN_null_culture_info_SHOULD_throw_null_reference_exception()
        {
            var taxes = new List <Tax>()
            {
                FakeCartFactory.CreateTax(_invariantCulture, 1, "CODE01", "DISP01")
            };
            var    instance = Container.CreateInstance <TaxViewModelFactory>();
            Action act      = () => instance.CreateTaxViewModels(taxes, null).ToList();

            act.ShouldThrow <NullReferenceException>();
        }
        public void WHEN_positive_tax_total_SHOULD_return_model()
        {
            var taxes = new List <Tax>()
            {
                FakeCartFactory.CreateTax(_invariantCulture, 1, "CODE01", "DISP01")
            };
            var instance = Container.CreateInstance <TaxViewModelFactory>();
            var models   = instance.CreateTaxViewModels(taxes, _invariantCulture).ToList();

            models.Should().NotBeNull();
            models.FirstOrDefault().Should().NotBeNull();
        }
        public int WHEN_null_zero_negative_tax_total_SHOULD_not_return_models_for_them(double?amount1, double?amount2, double?amount3)
        {
            List <Tax> taxes = new List <Tax>()
            {
                FakeCartFactory.CreateTax(_invariantCulture, amount1, "CODE01", "DISP01"),
                FakeCartFactory.CreateTax(_invariantCulture, amount2, "CODE02", "DISP02"),
                FakeCartFactory.CreateTax(_invariantCulture, amount3, "CODE03", "DISP03")
            };
            var instance = Container.CreateInstance <TaxViewModelFactory>();
            var models   = instance.CreateTaxViewModels(taxes, _invariantCulture).ToList();

            return(models.Count());
        }
        public void WHEN_cart_has_coupons_SHOULD_return_coupon_viewmodel_with_correct_values()
        {
            //Arrange
            UseCountryServiceMock();
            var rewardList = Enumerable.Repeat(new Reward
            {
                CampaignName = GetRandom.String(10),
                Amount       = GetRandom.Decimal(),
                PromotionId  = GetRandom.Guid(),
            }, 2).ToList();

            var p = new CreateCartViewModelParam()
            {
                Cart = FakeCartFactory.CreateCarttWithCoupon(new List <Reward>()
                {
                    rewardList[0]
                }, new List <Reward>()
                {
                    rewardList[1]
                }),
                CultureInfo      = CultureInfo.InvariantCulture,
                BaseUrl          = GetRandom.String(32),
                ProductImageInfo = new ProductImageInfo
                {
                    ImageUrls = new List <ProductMainImage>()
                }
            };

            var sut = Container.CreateInstance <CartViewModelFactory>();

            //Act
            var vm = sut.CreateCartViewModel(p);

            //Assert
            vm.Should().NotBeNull();
            vm.Coupons.ApplicableCoupons.Should().NotBeNull();
            vm.Coupons.ApplicableCoupons.Count.Should().Be(2);

            for (int i = 0; i < vm.Coupons.ApplicableCoupons.Count; i++)
            {
                var currentReward    = rewardList[i];
                var applicableCoupon = vm.Coupons.ApplicableCoupons.FirstOrDefault(c => c.PromotionId == currentReward.PromotionId);
                applicableCoupon.Should().NotBeNull();
                applicableCoupon.PromotionId.Should().Be(currentReward.PromotionId);
                applicableCoupon.Amount.Should().Be(currentReward.Amount);
            }
        }
        public void WHEN_invariant_culture_SHOULD_not_modify_display_name(string locValue1, string locValue2, string locValue3)
        {
            List <Tax> taxes = new List <Tax>()
            {
                FakeCartFactory.CreateTax(_invariantCulture, 1, "CODE01", locValue1),
                FakeCartFactory.CreateTax(_invariantCulture, 1, "CODE02", locValue2),
                FakeCartFactory.CreateTax(_invariantCulture, 1, "CODE03", locValue3)
            };
            var instance = Container.CreateInstance <TaxViewModelFactory>();
            var models   = instance.CreateTaxViewModels(taxes, _invariantCulture).ToList();

            for (int i = 0; i < models.Count; i++)
            {
                var currentTax   = models[i];
                var taxReference = taxes[i];
                currentTax.DisplayName.Should().Be(taxReference.DisplayName.GetLocalizedValue(_invariantCulture.Name));
            }
        }
        public void WHEN_positive_tax_total_SHOULD_not_modify_total_amount_and_percentage(double?amount, double percentage)
        {
            var baseTax = FakeCartFactory.CreateTax(_invariantCulture, amount, "CODE01", "DISP01");

            baseTax.Percentage = percentage;
            List <Tax> taxes = new List <Tax>()
            {
                baseTax
            };

            var instance = Container.CreateInstance <TaxViewModelFactory>();
            var models   = instance.CreateTaxViewModels(taxes, _invariantCulture).ToList();

            models.Count().Should().Be(1);

            var modelTax = models.First();

            modelTax.Percentage.Should().Be(percentage.ToString());
            modelTax.TaxTotal.Should().Be((decimal)amount);
        }
        public void WHEN_cart_has_invalid_coupons_and_IncludeInvalidCouponsMessages_is_true_SHOULD_include_message()
        {
            //Arrange
            UseCountryServiceMock();

            const int validCouponsCount   = 1;
            const int invalidCouponsCount = 2;

            var p = new CreateCartViewModelParam()
            {
                Cart = new Overture.ServiceModel.Orders.Cart()
                {
                    Coupons = new List <Coupon>()
                    {
                        FakeCartFactory.CreateInvalidCoupon(),
                FakeCartFactory.CreateInvalidCoupon(),
                FakeCartFactory.CreateValidCoupon()
                    }
                },
                CultureInfo      = CultureInfo.InvariantCulture,
                BaseUrl          = GetRandom.String(32),
                ProductImageInfo = new ProductImageInfo()
                {
                    ImageUrls = new List <ProductMainImage>()
                },
                IncludeInvalidCouponsMessages = true
            };

            var sut = Container.CreateInstance <CartViewModelFactory>();

            //Act
            var vm = sut.CreateCartViewModel(p);

            //Assert
            vm.Should().NotBeNull();
            vm.Coupons.Should().NotBeNull();
            vm.Coupons.ApplicableCoupons.Should().HaveCount(validCouponsCount);
            vm.Coupons.Messages.Should().HaveCount(invalidCouponsCount);
        }