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 basket(self):
"""
The basket used in this checkout process.
:rtype: E-Commerce.front.basket.objects.BaseBasket
"""
return get_basket(self.request)
def test_set_non_shop_member_customer(rf):
"""
Set some customer to the basket that is not member of the shop
"""
with override_settings(**CORE_BASKET_SETTINGS):
shop = factories.get_shop(False)
assert shop != factories.get_default_shop()
user = factories.create_random_user()
request = apply_request_middleware(rf.get("/"), user=user)
basket = get_basket(request, "basket")
basket.customer = get_person_contact(user)
assert basket.shop == factories.get_default_shop()
person = factories.create_random_person()
person.shops.add(shop)
company = factories.create_random_company()
company.add_to_shop(shop)
for customer in [person, company]:
with pytest.raises(ValidationError) as exc:
basket_commands.handle_set_customer(request, basket, customer)
assert exc.value.code == "invalid_customer_shop"
assert basket.customer == get_person_contact(user)
def test_category_product_in_basket_condition(rf):
request, shop, group = initialize_test(rf, False)
basket = get_basket(request)
supplier = get_default_supplier()
category = get_default_category()
product = create_product("The Product", shop=shop, default_price="200", supplier=supplier)
basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1)
basket.shipping_method = get_shipping_method(shop=shop)
shop_product = product.get_shop_instance(shop)
assert category not in shop_product.categories.all()
condition = CategoryProductsBasketCondition.objects.create(operator=ComparisonOperator.EQUALS, quantity=1)
condition.categories.add(category)
# No match the product does not have the category
assert not condition.matches(basket, [])
category.shop_products.add(shop_product)
assert condition.matches(basket, [])
basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1)
assert not condition.matches(basket, [])
condition.operator = ComparisonOperator.GTE
condition.save()
assert condition.matches(basket, [])
condition.excluded_categories.add(category)
assert not condition.matches(basket, [])
with pytest.raises(CampaignsInvalidInstanceForCacheUpdate):
update_filter_cache("test", shop)
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_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_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_basket_shipping_error(rf):
StoredBasket.objects.all().delete()
shop = get_default_shop()
supplier = get_default_supplier()
shipped_product = create_product(
printable_gibberish(), shop=shop, supplier=supplier, default_price=50,
shipping_mode=ShippingMode.SHIPPED
)
unshipped_product = create_product(
printable_gibberish(), shop=shop, supplier=supplier, default_price=50,
shipping_mode=ShippingMode.NOT_SHIPPED
)
request = rf.get("/")
request.session = {}
request.shop = shop
apply_request_middleware(request)
basket = get_basket(request)
# With a shipped product but no shipping methods, we oughta get an error
basket.add_product(supplier=supplier, shop=shop, product=shipped_product, quantity=1)
assert any(ve.code == "no_common_shipping" for ve in basket.get_validation_errors())
basket.clear_all()
# But with an unshipped product, we should not
basket.add_product(supplier=supplier, shop=shop, product=unshipped_product, quantity=1)
assert not any(ve.code == "no_common_shipping" for ve in basket.get_validation_errors())
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_add_product_with_extra_parent_line(rf):
"""
Add product to basket with extra info and parent line
"""
with override_settings(**CORE_BASKET_SETTINGS):
shop = factories.get_default_shop()
user = factories.create_random_user()
product = factories.create_product("product", shop, factories.get_default_supplier(), 10)
request = apply_request_middleware(rf.get("/"), user=user)
basket = get_basket(request, "basket")
basket.customer = get_person_contact(user)
cmd_response = basket_commands.handle_add(request, basket, product.id, 1, extra={"more": "stuff"})
line_id1 = cmd_response["line_id"]
assert cmd_response["ok"]
line1 = basket.get_basket_line(line_id1)
assert line1._data["more"] == "stuff"
cmd_response = basket_commands.handle_add(
request, basket, product.id, 1, parent_line=line1, force_new_line=True)
line_id2 = cmd_response["line_id"]
assert cmd_response["ok"]
line2 = basket.get_basket_line(line_id2)
assert not line2._data
assert line_id1 != line_id2
assert line2.parent_line.line_id == line_id1
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_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 _get_order_with_coupon(request, initial_status, condition_product_count=1):
shop = request.shop
basket = get_basket(request)
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=1)
basket.shipping_method = get_shipping_method(shop=shop) # For shippable products
dc = Coupon.objects.create(code="TEST", 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=1)
campaign.conditions.add(rule)
campaign.save()
basket.add_code(dc.code)
basket.save()
basket.status = initial_status
creator = OrderCreator(request)
order = creator.create_order(basket)
assert order.lines.count() == 3
assert OrderLineType.DISCOUNT in [l.type for l in order.lines.all()]
return order
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 test_productfilter_works():
rf = RequestFactory()
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_product_in_basket_condition_with_variation_parent(rf):
request, shop, group = initialize_test(rf, False)
basket = get_basket(request)
supplier = get_default_supplier()
product = create_product(
"test-product", shop, default_price="200", supplier=supplier, mode=ProductMode.SIMPLE_VARIATION_PARENT)
child_products = []
for x in range(0, 3):
child_product = create_product("test-product-%s" % x, shop, default_price="10", supplier=supplier)
child_product.link_to_parent(product)
child_products.append(child_product)
condition = ProductsInBasketCondition.objects.create()
condition.values = [product]
condition.operator = ComparisonOperator.EQUALS
condition.quantity = 3
condition.save()
assert not condition.matches(basket, [])
for child_product in child_products:
basket.add_product(supplier=supplier, shop=shop, product=child_product, quantity=1)
assert condition.matches(basket, [])
def test_basket_campaign_with_multiple_supppliers(rf):
request, shop, group = initialize_test(rf, False)
supplier1 = Supplier.objects.create(identifier="1")
supplier2 = Supplier.objects.create(identifier="2")
price = shop.create_price
basket = get_basket(request)
single_product_price = "50"
discount_amount_supplier1 = "10"
discount_amount_supplier2 = "40"
product1 = create_product("product1", shop=shop, supplier=supplier1, default_price=single_product_price)
product2 = create_product("product2", shop=shop, supplier=supplier2, default_price=single_product_price)
basket.add_product(supplier=supplier1, shop=shop, product=product1, quantity=1)
basket.add_product(supplier=supplier2, shop=shop, product=product2, quantity=1)
basket.shipping_method = get_shipping_method(shop=shop)
basket.save()
assert basket.product_count == 2
assert basket.total_price.value == 100
# Create campaign for supplier one
basket_rule1 = ProductsInBasketCondition.objects.create(quantity=1)
basket_rule1.products.add(product1)
campaign = BasketCampaign.objects.create(
shop=shop, public_name="test", name="test", active=True, supplier=supplier1)
campaign.conditions.add(basket_rule1)
campaign.save()
BasketDiscountAmount.objects.create(
campaign=campaign, discount_amount=discount_amount_supplier1)
basket.uncache()
lines = basket.get_final_lines()
assert len(lines) == 4
assert basket.total_price.value == 90 # 10d discount from the supplier1 product
line = _get_discount_line(lines, 10)
assert line.supplier == supplier1
# Create campaign for supplier two
basket_rule2 = ProductsInBasketCondition.objects.create(quantity=1)
basket_rule2.products.add(product2)
campaign = BasketCampaign.objects.create(
shop=shop, public_name="test", name="test", active=True, supplier=supplier2)
campaign.conditions.add(basket_rule2)
campaign.save()
BasketDiscountAmount.objects.create(
campaign=campaign, discount_amount=discount_amount_supplier2)
basket.uncache()
lines = basket.get_final_lines()
assert len(lines) == 5
assert basket.total_price.value == 50 # -10d - 40d from 100d
line = _get_discount_line(lines, 40)
assert line.supplier == supplier2
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_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_basket_package_product_orderability_change(rf):
if "E-Commerce.simple_supplier" not in settings.INSTALLED_APPS:
pytest.skip("Need E-Commerce.simple_supplier in INSTALLED_APPS")
from E-Commerce_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_basket_free_product(rf):
request, shop, _ = initialize_test(rf, False)
basket = get_basket(request)
supplier = get_default_supplier()
single_product_price = "50"
original_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=2)
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)
# no shop
third_product = create_product(printable_gibberish(), supplier=supplier)
rule = BasketTotalProductAmountCondition.objects.create(value="2")
campaign = BasketCampaign.objects.create(active=True, shop=shop, name="test", public_name="test")
campaign.conditions.add(rule)
effect = FreeProductLine.objects.create(campaign=campaign, quantity=2)
effect.products.add(second_product)
discount_lines_count = len(effect.get_discount_lines(basket, [], supplier))
assert discount_lines_count == 1
# do not affect as there is no shop product for the product
effect.products.add(third_product)
assert len(effect.get_discount_lines(basket, [], supplier)) == discount_lines_count
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
assert line.line_source == LineSource.DISCOUNT_MODULE
assert line.quantity == original_quantity
else:
assert line.line_source == LineSource.CUSTOMER
def test_set_from_anonymous_to_customer_not_auth(rf):
"""
Set some customer to the basket when not authenticated
"""
with override_settings(**CORE_BASKET_SETTINGS):
request = apply_request_middleware(rf.get("/"))
basket = get_basket(request, "basket")
basket.customer = AnonymousContact()
customer = factories.create_random_person()
assert basket_commands.handle_set_customer(request, basket, customer)["ok"] is True
assert basket.customer == customer
def test_set_from_admin_to_anonymous(admin_user, rf):
"""
Set anonymous to the basket customer
"""
with override_settings(**CORE_BASKET_SETTINGS):
request = apply_request_middleware(rf.get("/"), user=admin_user)
basket = get_basket(request, "basket")
basket.customer = get_person_contact(admin_user)
assert basket_commands.handle_set_customer(request, basket, AnonymousContact())["ok"] is True
assert basket.customer == AnonymousContact()
assert basket.orderer == AnonymousContact()
assert basket.creator == admin_user
def _init_test_for_product_with_basket(rf, default_price):
request, product = _init_test_for_product_without_basket(rf, default_price)
shop = factories.get_default_shop()
supplier = factories.get_default_supplier()
basket = get_basket(request)
basket.status = factories.get_initial_order_status()
basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1)
basket.shipping_method = factories.get_shipping_method(shop=shop)
basket.payment_method = factories.get_payment_method(shop=shop)
assert basket.shop == request.shop
assert basket.customer == request.customer
return request, product, basket
def test_undiscounted_effects(rf, include_tax):
request, shop, _ = initialize_test(rf, include_tax)
basket = get_basket(request)
supplier = get_default_supplier()
single_product_price = Decimal(50)
discounted_product_quantity = 4
normal_priced_product_quantity = 2
discount_percentage = Decimal(0.2) # 20%
discount_amount = basket.create_price(single_product_price * normal_priced_product_quantity * discount_percentage)
category = CategoryFactory()
discounted_product = create_product(
printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price)
second_product = create_product(
printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price)
ShopProduct.objects.get(shop=shop, product=discounted_product).categories.add(category)
ShopProduct.objects.get(shop=shop, product=second_product).categories.add(category)
basket.add_product(supplier=supplier, shop=shop, product=discounted_product, quantity=discounted_product_quantity)
basket.add_product(supplier=supplier, shop=shop, product=second_product, quantity=normal_priced_product_quantity)
basket.shipping_method = get_shipping_method(shop=shop)
basket.save()
# Store basket price before any campaigns exists
original_price = basket.total_price
# 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)
# BasketCampaign
campaign = BasketCampaign.objects.create(
active=True, shop=shop, name="test2", public_name="test2")
final_lines = basket.get_final_lines()
assert len(final_lines) == 3
# Discount based on undiscounted product values
DiscountPercentageFromUndiscounted.objects.create(campaign=campaign, discount_percentage=discount_percentage)
basket.uncache()
final_lines = basket.get_final_lines()
assert len(final_lines) == 4
discounted_basket_price = original_price - discount_amount
assert basket.total_price.as_rounded() == discounted_basket_price.as_rounded()
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() if line.type == OrderLineType.DISCOUNT]
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))
assert basket.codes == [dc.code]
# test code removal
resp = handle_remove_campaign_code(request, basket, dc.code)
assert resp.get("ok")
assert basket.codes == []
discount_lines_values = [line.discount_amount for line in basket.get_final_lines() if line.type == OrderLineType.DISCOUNT]
assert price(discount1) in discount_lines_values
assert not price(discount2) in discount_lines_values
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_product_category_discount_amount_with_minimum_price(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 = Decimal("50")
single_product_min_price = Decimal("40")
discount_amount_value = Decimal("200") # will exceed the minimum price
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)
shop_product = ShopProduct.objects.get(shop=shop, product=product)
shop_product.minimum_price_value = single_product_min_price
shop_product.save()
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 = 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_amount=discount_amount_value,
category=category)
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 _create_order(request, customer, coupon, product, expected_product_price):
creator = OrderCreator(request)
shop = request.shop
request.basket = None
request.customer = customer
basket = get_basket(request)
basket.status = factories.get_initial_order_status()
basket.add_product(supplier=factories.get_default_supplier(), shop=shop, product=product, quantity=1)
basket.shipping_method = factories.get_shipping_method(shop=shop)
basket.payment_method = factories.get_payment_method(shop=shop)
basket.add_code(coupon)
assert basket.shop == request.shop
assert basket.customer == request.customer
assert product.get_price_info(request).price == expected_product_price
creator.create_order(basket)