def test_parallel_baskets(rf): request = get_request_with_basket() shop = get_default_shop() customer = create_random_person() request = rf.get("/") request.shop = shop apply_request_middleware(request) request.customer = customer basket_one = get_basket(request, basket_name="basket_one") basket_two = get_basket(request, basket_name="basket_two") product_one = get_default_product() product_two = get_default_product() product_two.sku = "derpy-hooves" sales_unit = SalesUnit.objects.create(identifier="test-sales-partial", decimals=2, name="Partial unit") product_two.sales_unit = sales_unit # Set the sales unit for the product product_two.save() basket_commands.handle_add(request, basket_one, product_id=product_one.pk, quantity=1) basket_commands.handle_add(request, basket_two, product_id=product_two.pk, quantity=3.5) assert basket_one.product_count == 1 assert basket_two.product_count == 3.5
def test_basket(rf): StoredBasket.objects.all().delete() quantities = [3, 12, 44, 23, 65] shop = get_default_shop() get_default_payment_method( ) # Can't create baskets without payment methods supplier = get_default_supplier() products_and_quantities = [] for quantity in quantities: product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=50) products_and_quantities.append((product, quantity)) for product, q in products_and_quantities: request = rf.get("/") request.session = {} request.shop = shop apply_request_middleware(request) basket = get_basket(request) assert basket == request.basket assert basket.product_count == 0 line = basket.add_product(supplier=supplier, shop=shop, product=product, quantity=q) basket.shipping_method = get_shipping_method( shop=shop) # For shippable product assert line.quantity == q assert basket.get_lines() assert basket.get_product_ids_and_quantities().get(product.pk) == q assert basket.product_count == q basket.save() delattr(request, "basket") basket = get_basket(request) assert basket.get_product_ids_and_quantities().get(product.pk) == q product_ids = set(StoredBasket.objects.last().products.values_list( "id", flat=True)) assert product_ids == set([product.pk]) stats = StoredBasket.objects.all().aggregate( n=Sum("product_count"), tfs=Sum("taxful_total_price_value"), tls=Sum("taxless_total_price_value"), ) assert stats["n"] == sum(quantities) if shop.prices_include_tax: assert stats["tfs"] == sum(quantities) * 50 else: assert stats["tls"] == sum(quantities) * 50 basket.finalize()
def test_contact_group_basket_condition_with_none(rf): request = apply_request_middleware(rf.get("/")) request.shop = Shop() basket = get_basket(request) condition = ContactGroupBasketCondition.objects.create() result = condition.matches(basket) # Should not raise any errors assert result is False
def create_basket_and_campaign(request, conditions, product_price_value, campaign_discount_value): product = create_product("Some crazy product", request.shop, get_default_supplier(), default_price=product_price_value) basket = get_basket(request) basket.customer = request.customer supplier = get_default_supplier() basket.add_product(supplier=supplier, shop=request.shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=request.shop) original_line_count = len(basket.get_final_lines()) assert original_line_count == 2 assert basket.product_count == 1 original_price = basket.total_price campaign = BasketCampaign.objects.create(shop=request.shop, name="test", public_name="test", active=True) BasketDiscountAmount.objects.create( campaign=campaign, discount_amount=campaign_discount_value) for condition in conditions: campaign.conditions.add(condition) assert campaign.is_available() return basket, original_line_count, original_price
def _init_basket_coupon_test(rf, code="TEST"): status = get_initial_order_status() request, shop, group = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() for x in range(2): product = create_product(printable_gibberish(), shop, supplier=supplier, default_price="50") basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method( shop=shop) # For shippable products dc = Coupon.objects.create(code=code, active=True) campaign = BasketCampaign.objects.create(shop=shop, name="test", public_name="test", coupon=dc, active=True) BasketDiscountAmount.objects.create( discount_amount=shop.create_price("20"), campaign=campaign) rule = BasketTotalProductAmountCondition.objects.create(value=2) campaign.conditions.add(rule) campaign.save() return basket, dc, request, status
def basket(self): """ The basket used in this checkout process. :rtype: wshop.front.basket.objects.BaseBasket """ return get_basket(self.request)
def test_basket_total_amount_conditions(rf): request, shop, group = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() product = create_product("Just-A-Product-Too", shop, default_price="200", supplier=supplier) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) condition = BasketTotalAmountCondition.objects.create() condition.value = 1 condition.save() assert condition.value == 1 assert condition.matches(basket, []) condition2 = BasketMaxTotalAmountCondition.objects.create() condition2.value = 200 condition2.save() assert condition2.matches(basket, []) condition2.value = 199 condition2.save() assert not condition2.matches(basket, [])
def test_basket_total_value_conditions(rf): request, shop, group = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() product = create_product("Just-A-Product-Too", shop, default_price="200", supplier=supplier) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) condition = BasketTotalProductAmountCondition.objects.create() condition.value = 1 condition.save() assert condition.value == 1 assert condition.matches(basket, []) assert "basket has at least the product count entered here" in force_text( condition.description) condition2 = BasketMaxTotalProductAmountCondition.objects.create() condition2.value = 1 condition2.save() assert condition2.matches(basket, []) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert not condition2.matches(basket, [])
def test_percentage_campaign(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() # create a basket rule that requires at least value of 200 rule = BasketTotalAmountCondition.objects.create(value="200") product_price = "200" discount_percentage = "0.1" expected_discounted_price = price(product_price) - (price(product_price) * Decimal(discount_percentage)) product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) campaign = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", active=True) campaign.conditions.add(rule) campaign.save() BasketDiscountPercentage.objects.create(campaign=campaign, discount_percentage=discount_percentage) assert len(basket.get_final_lines()) == 3 assert basket.product_count == 1 assert basket.total_price == expected_discounted_price
def test_productfilter_works(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price product_price = "100" discount_percentage = "0.30" supplier = get_default_supplier() product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=product_price) shop_product = product.get_shop_instance(shop) # create catalog campaign catalog_filter = ProductFilter.objects.create() catalog_filter.products.add(product) assert catalog_filter.matches(shop_product) catalog_campaign = CatalogCampaign.objects.create(shop=shop, active=True, name="test") catalog_campaign.filters.add(catalog_filter) cdp = ProductDiscountPercentage.objects.create(campaign=catalog_campaign, discount_percentage=discount_percentage) # add product to basket basket = get_basket(request) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) basket.save() expected_total = price(product_price) - (Decimal(discount_percentage) * price(product_price)) assert basket.total_price == expected_total
def test_only_cheapest_price_is_selected(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() # create a basket rule that requires atleast value of 200 rule = BasketTotalAmountCondition.objects.create(value="200") product_price = "200" discount1 = "10" discount2 = "20" # should be selected product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) campaign1 = BasketCampaign.objects.create(shop=shop, public_name="test", name="test", active=True) campaign1.conditions.add(rule) campaign1.save() BasketDiscountAmount.objects.create(discount_amount=discount1, campaign=campaign1) campaign2 = BasketCampaign.objects.create(shop=shop, public_name="test", name="test", active=True) campaign2.conditions.add(rule) campaign2.save() BasketDiscountAmount.objects.create(discount_amount=discount2, campaign=campaign2) assert len(basket.get_final_lines()) == 3 line_types = [l.type for l in basket.get_final_lines()] assert OrderLineType.DISCOUNT in line_types for line in basket.get_final_lines(): if line.type == OrderLineType.DISCOUNT: assert line.discount_amount == price(discount2)
def test_campaign_with_coupons1(rf): basket, dc, request, status = _init_basket_coupon_test(rf) assert len(basket.get_final_lines() ) == 3 # no discount was applied because coupon is required basket.add_code(dc.code) assert len(basket.get_final_lines() ) == 4 # now basket has codes so they will be applied too assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()] # Ensure codes persist between requests, so do what the middleware would, i.e. basket.save() # and then reload the basket: del request.basket basket = get_basket(request) assert basket.codes == [dc.code] assert len(basket.get_final_lines() ) == 4 # now basket has codes so they will be applied too assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()] basket.status = status creator = OrderCreator(request) order = creator.create_order(basket) assert CouponUsage.objects.filter(order=order).count() == 1 assert CouponUsage.objects.filter(order=order, coupon__code=dc.code).count() == 1
def test_basket_clearing(rf): StoredBasket.objects.all().delete() shop = get_default_shop() supplier = get_default_supplier() product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=50) request = rf.get("/") request.session = {} request.shop = shop apply_request_middleware(request) basket = get_basket(request) pm = get_default_payment_method() sm = get_default_shipping_method() basket.shipping_method = sm basket.payment_method = pm basket.save() assert basket.shipping_method assert basket.payment_method basket.clear_all() assert not basket.shipping_method assert not basket.payment_method
def test_basket_orderability_change_shop_product(rf): StoredBasket.objects.all().delete() shop = get_default_shop() supplier = get_default_supplier() product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=50) request = rf.get("/") request.session = {} request.shop = shop apply_request_middleware(request) basket = get_basket(request) line = basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1, force_new_line=True, extra={"foo": "foo"}) assert len(basket.get_lines()) == 1 assert len(basket.get_unorderable_lines()) == 0 product.get_shop_instance(shop).delete() basket.uncache() assert basket.dirty assert len(basket.get_lines()) == 0 assert len(basket.get_unorderable_lines()) == 1
def test_basket_free_product_coupon(rf): request, shop, _ = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() single_product_price = "50" # create basket rule that requires 2 products in basket product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) basket.save() second_product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) rule = BasketTotalProductAmountCondition.objects.create(value="2") coupon = Coupon.objects.create(code="TEST", active=True) campaign = BasketCampaign.objects.create(active=True, shop=shop, name="test", public_name="test", coupon=coupon) campaign.conditions.add(rule) effect = FreeProductLine.objects.create(campaign=campaign) effect.products.add(second_product) basket.add_code(coupon.code) basket.uncache() final_lines = basket.get_final_lines() assert len(final_lines) == 3 line_types = [l.type for l in final_lines] assert OrderLineType.DISCOUNT not in line_types for line in basket.get_final_lines(): assert line.type in [OrderLineType.PRODUCT, OrderLineType.SHIPPING] if line.type == OrderLineType.SHIPPING: continue if line.product != product: assert line.product == second_product
def test_product_category_discount_percentage_greater_then_products( rf, include_tax): # Buy X amount of Y get Z discount from Y request, shop, _ = initialize_test(rf, include_tax) basket = get_basket(request) supplier = get_default_supplier() single_product_price = "50" discount_percentage = Decimal(1.9) # 190% quantity = 2 # the expected discount amount should not be greater than the products expected_discount_amount = basket.create_price( single_product_price) * quantity category = CategoryFactory() # create basket rule that requires 2 products in basket product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) ShopProduct.objects.get(shop=shop, product=product).categories.add(category) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=quantity) basket.shipping_method = get_shipping_method(shop=shop) basket.save() rule = ProductsInBasketCondition.objects.create(quantity=2) rule.products.add(product) rule.save() campaign = BasketCampaign.objects.create(active=True, shop=shop, name="test", public_name="test") campaign.conditions.add(rule) DiscountFromCategoryProducts.objects.create( campaign=campaign, discount_percentage=discount_percentage, category=category) assert rule.matches(basket, []) basket.uncache() final_lines = basket.get_final_lines() assert len(final_lines ) == 2 # no new lines since the effect touches original lines original_price = basket.create_price(single_product_price) * quantity line = final_lines[0] assert line.discount_amount == expected_discount_amount assert basket.total_price == original_price - expected_discount_amount
def test_basket_data_fields(rf): StoredBasket.objects.all().delete() shop = get_default_shop() request = rf.get("/") request.session = {} request.shop = shop apply_request_middleware(request) basket = get_basket(request) basket.shipping_data = {"shipment": True} basket.payment_data = {"payment": True} basket.extra_data = {"extra": True} basket.save() request.basket = None request.baskets = None basket = get_basket(request) assert basket.shipping_data["shipment"] is True assert basket.payment_data["payment"] is True assert basket.extra_data["extra"] is True
def test_productdiscountamount_with_minimum_price(rf, per_line_discount): # Buy X amount of Y get Z discount from Y request, shop, _ = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() single_product_price = Decimal("50") single_product_min_price = Decimal("40") discount_amount_value = Decimal("200") # will exceed the minimum price quantity = 2 # create basket rule that requires 2 products in basket product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) shop_product = ShopProduct.objects.get(product=product, shop=shop) shop_product.minimum_price_value = single_product_min_price shop_product.save() basket.add_product(supplier=supplier, shop=shop, product=product, quantity=quantity) basket.shipping_method = get_shipping_method(shop=shop) basket.save() rule = ProductsInBasketCondition.objects.create(quantity=2) rule.products.add(product) rule.save() campaign = BasketCampaign.objects.create(active=True, shop=shop, name="test", public_name="test") campaign.conditions.add(rule) effect = DiscountFromProduct.objects.create( campaign=campaign, discount_amount=discount_amount_value, per_line_discount=per_line_discount) effect.products.add(product) assert rule.matches(basket, []) basket.uncache() # the discount amount should not exceed the minimum price. as the configued discount # will exceed, it should limit the discount amount final_lines = basket.get_final_lines() expected_discount_amount = basket.create_price( (single_product_price - single_product_min_price) * quantity) original_price = basket.create_price(single_product_price) * quantity line = final_lines[0] assert line.discount_amount == expected_discount_amount assert basket.total_price == original_price - expected_discount_amount
def test_basket_package_product_orderability_change(rf): if "wshop.simple_supplier" not in settings.INSTALLED_APPS: pytest.skip("Need wshop.simple_supplier in INSTALLED_APPS") from wshop_tests.simple_supplier.utils import get_simple_supplier StoredBasket.objects.all().delete() shop = get_default_shop() supplier = get_simple_supplier() product, child = get_unstocked_package_product_and_stocked_child( shop, supplier, child_logical_quantity=2) request = rf.get("/") request.session = {} request.shop = shop apply_request_middleware(request) basket = get_basket(request) # Add the package parent basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1, force_new_line=True, extra={"foo": "foo"}) # Also add the child product separately basket.add_product(supplier=supplier, shop=shop, product=child, quantity=1, force_new_line=True, extra={"foo": "foo"}) # Should be stock for both assert len(basket.get_lines()) == 2 assert len(basket.get_unorderable_lines()) == 0 supplier.adjust_stock(child.id, -1) # Orderability is already cached, we need to uncache to force recheck basket.uncache() # After reducing stock to 1, should only be stock for one assert len(basket.get_lines()) == 1 assert len(basket.get_unorderable_lines()) == 1 supplier.adjust_stock(child.id, -1) basket.uncache() # After reducing stock to 0, should be stock for neither assert len(basket.get_lines()) == 0 assert len(basket.get_unorderable_lines()) == 2
def test_category_products_effect_with_amount(rf): request, shop, group = initialize_test(rf, False) basket = get_basket(request) category = get_default_category() supplier = get_default_supplier() single_product_price = "50" discount_amount_value = "10" quantity = 5 product = create_product("The product", shop=shop, supplier=supplier, default_price=single_product_price) shop_product = product.get_shop_instance(shop) shop_product.categories.add(category) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=quantity) basket.shipping_method = get_shipping_method(shop=shop) basket.save() rule = CategoryProductsBasketCondition.objects.create( operator=ComparisonOperator.EQUALS, quantity=quantity) rule.categories.add(category) campaign = BasketCampaign.objects.create(active=True, shop=shop, name="test", public_name="test") campaign.conditions.add(rule) DiscountFromCategoryProducts.objects.create( campaign=campaign, category=category, discount_amount=discount_amount_value) assert rule.matches(basket, []) basket.uncache() final_lines = basket.get_final_lines() assert len(final_lines ) == 2 # no new lines since the effect touches original lines expected_discount_amount = quantity * basket.create_price( discount_amount_value) original_price = basket.create_price(single_product_price) * quantity line = final_lines[0] assert line.discount_amount == expected_discount_amount assert basket.total_price == original_price - expected_discount_amount
def test_basket_category_discount(rf): """ Test that discounting based on product category works. """ request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() category = CategoryFactory() discount_amount_value = 6 single_product_price = 10 def create_category_product(category): product = create_product(printable_gibberish(), shop, supplier, single_product_price) product.primary_category = category sp = ShopProduct.objects.get(product=product, shop=shop) sp.primary_category = category sp.categories.add(category) return product basket_condition = CategoryProductsBasketCondition.objects.create(quantity=2) basket_condition.categories.add(category) campaign = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", active=True ) campaign.conditions.add(basket_condition) campaign.save() DiscountFromCategoryProducts.objects.create( campaign=campaign, discount_amount=discount_amount_value, category=category ) basket.save() products = [create_category_product(category) for i in range(2)] for product in products: basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) basket.save() assert basket.product_count == 2 assert basket_condition.matches(basket=basket, lines=basket.get_lines()) assert campaign.rules_match(basket, basket.get_lines()) assert basket.total_price == price(single_product_price * 2) - price(discount_amount_value * 2)
def test_method_phase_basic(rf, admin_user, get_method, data, method_id): activate("en") shop = get_default_shop() method = get_method(shop, price=0, name=data["name"]) method.description = data["description"] method.save() assert method.enabled view = MethodsOnlyCheckoutView.as_view() # To make method visible, basket must be available person = get_person_contact(admin_user) request = apply_request_middleware(rf.get("/")) request.shop = shop request.user = admin_user request.person = person request.customer = person basket = get_basket(request) # add product to bakset supplier = get_default_supplier() product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=50) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=2) assert basket.product_count, "basket has products" basket.save() request = apply_request_middleware(request, user=admin_user, person=person, customer=person, basket=basket) # request = apply_request_middleware(rf.get("/")) response = view(request=request, phase='methods') if hasattr(response, "render"): response.render() assert response.status_code in [200, 302] soup = BeautifulSoup(response.content) method_soup = soup.find("div", {"id": method_id}) assert data["name"] in method_soup.text assert data["description"] in method_soup.text assert soup.find("input", {"id": "%s_%s" % (method_id, method.pk)})
def test_productdiscountamount(rf): # Buy X amount of Y get Z discount from Y request, shop, _ = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() single_product_price = "50" discount_amount_value = "10" quantity = 2 # create basket rule that requires 2 products in basket product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=quantity) basket.shipping_method = get_shipping_method(shop=shop) basket.save() rule = ProductsInBasketCondition.objects.create(quantity=2) rule.products.add(product) rule.save() campaign = BasketCampaign.objects.create(active=True, shop=shop, name="test", public_name="test") campaign.conditions.add(rule) effect = DiscountFromProduct.objects.create( campaign=campaign, discount_amount=discount_amount_value) effect.products.add(product) assert rule.matches(basket, []) basket.uncache() final_lines = basket.get_final_lines() assert len(final_lines ) == 2 # no new lines since the effect touches original lines expected_discount_amount = basket.create_price(discount_amount_value) original_price = basket.create_price(single_product_price) * quantity line = final_lines[0] assert line.discount_amount == expected_discount_amount assert basket.total_price == original_price - expected_discount_amount
def test_basket_total_undiscounted_value_conditions(rf): request, shop, group = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() product = create_product("Just-A-Product", shop, default_price="150", supplier=supplier) discounted_product = create_product("Just-A-Second-Product", shop, default_price="200", supplier=supplier) # CatalogCampaign catalog_campaign = CatalogCampaign.objects.create(active=True, shop=shop, name="test", public_name="test") # Limit catalog campaign to "discounted_product" product_filter = ProductFilter.objects.create() product_filter.products.add(discounted_product) catalog_campaign.filters.add(product_filter) basket.add_product(supplier=supplier, shop=shop, product=discounted_product, quantity=1) condition = BasketTotalUndiscountedProductAmountCondition.objects.create() condition.value = 1 condition.save() assert not condition.matches(basket, []) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert condition.matches(basket, []) # Too high amount for undiscounted value condition.value = 151 condition.save() assert not condition.matches(basket, [])
def test_basket_campaign_case2(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() # create a basket rule that requires at least value of 200 rule = BasketTotalAmountCondition.objects.create(value="200") single_product_price = "50" discount_amount_value = "10" unique_shipping_method = get_shipping_method(shop, price=50) for x in range(3): product = create_product( printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert basket.product_count == 3 campaign = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", active=True) campaign.conditions.add(rule) campaign.save() BasketDiscountAmount.objects.create(discount_amount=discount_amount_value, campaign=campaign) assert len(basket.get_final_lines()) == 3 assert basket.total_price == price(single_product_price) * basket.product_count # check that shipping method affects campaign basket.shipping_method = unique_shipping_method basket.save() basket.uncache() assert len(basket.get_final_lines()) == 4 # Shipping should not affect the rule being triggered line_types = [l.type for l in basket.get_final_lines()] assert OrderLineType.DISCOUNT not in line_types product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert len(basket.get_final_lines()) == 6 # Discount included assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()]
def test_basket_campaign_module_case1(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() single_product_price = "50" discount_amount_value = "10" # create basket rule that requires 2 products in basket basket_rule1 = BasketTotalProductAmountCondition.objects.create(value="2") product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) basket.save() assert basket.product_count == 1 campaign = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", active=True) campaign.conditions.add(basket_rule1) campaign.save() BasketDiscountAmount.objects.create(campaign=campaign, discount_amount=discount_amount_value) assert len(basket.get_final_lines()) == 2 # case 1 assert basket.total_price == price(single_product_price) # case 1 basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.save() assert len(basket.get_final_lines()) == 3 # case 1 assert basket.product_count == 2 assert basket.total_price == (price(single_product_price) * basket.product_count - price(discount_amount_value)) assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()] # Make sure disabling campaign disables it conditions assert campaign.conditions.filter(active=True).exists() campaign.active = False campaign.save() assert not campaign.conditions.filter(active=True).exists()
def test_basket_dirtying_with_fnl(rf): shop = get_default_shop() supplier = get_default_supplier() product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=50) request = rf.get("/") request.session = {} request.shop = shop apply_request_middleware(request) basket = get_basket(request) line = basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1, force_new_line=True, extra={"foo": "foo"}) assert basket.dirty # The change should have dirtied the basket
def test_campaign_with_coupons2(rf): basket, dc, request, status = _init_basket_coupon_test(rf, code="tEsT") assert len(basket.get_final_lines() ) == 3 # no discount was applied because coupon is required customer_code = "Test" # Customer typoed the code, should still match basket.add_code(customer_code) assert customer_code in basket.codes assert len(basket.codes) == 1 # only one code basket.add_code(customer_code.upper()) assert customer_code.upper() not in basket.codes assert len(basket.codes) == 1 # only one code assert len(basket.get_final_lines() ) == 4 # now basket has codes so they will be applied too assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()] # Ensure codes persist between requests, so do what the middleware would, i.e. basket.save() # and then reload the basket: del request.basket basket = get_basket(request) assert basket.codes != [dc.code] # they don't match like this assert [c.upper() for c in basket.codes] == [dc.code.upper()] # they match like this assert [c.upper() for c in basket.codes ] != [customer_code] # they don't match like this assert basket.codes == [customer_code] # they match like this assert len(basket.get_final_lines() ) == 4 # now basket has codes so they will be applied too assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()] basket.status = status creator = OrderCreator(request) order = creator.create_order(basket) assert CouponUsage.objects.filter(order=order).count() == 1 assert CouponUsage.objects.filter(order=order, coupon__code=dc.code).count() == 1
def test_product_in_basket_condition(rf): request, shop, group = initialize_test(rf, False) basket = get_basket(request) supplier = get_default_supplier() product = create_product("Just-A-Product-Too", shop, default_price="200", supplier=supplier) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) condition = ProductsInBasketCondition.objects.create() condition.values = [product] condition.save() assert condition.values.first() == product assert condition.matches(basket, []) condition.quantity = 2 condition.save() assert not condition.matches(basket, []) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert condition.matches(basket, []) condition.operator = ComparisonOperator.EQUALS condition.save() assert condition.matches(basket, []) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert not condition.matches(basket, [])
def test_multiple_campaigns_match_with_coupon(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() # create a basket rule that requires atleast value of 200 rule = BasketTotalAmountCondition.objects.create(value="200") product_price = "200" discount1 = "10" discount2 = "20" product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) basket.shipping_method = get_shipping_method(shop=shop) campaign = BasketCampaign.objects.create(shop=shop, public_name="test", name="test", active=True) campaign.conditions.add(rule) campaign.save() BasketDiscountAmount.objects.create(discount_amount=discount1, campaign=campaign) dc = Coupon.objects.create(code="TEST", active=True) campaign2 = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", coupon=dc, active=True ) BasketDiscountAmount.objects.create(discount_amount=discount2, campaign=campaign2) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) resp = handle_add_campaign_code(request, basket, dc.code) assert resp.get("ok") discount_lines_values = [line.discount_amount for line in basket.get_final_lines()] assert price(discount1) in discount_lines_values assert price(discount2) in discount_lines_values assert basket.total_price == (price(product_price) * basket.product_count - price(discount1) - price(discount2))