def test_get_discount_for_checkout_entire_order_voucher_not_applicable(
total,
total_quantity,
discount_value,
discount_type,
min_spent_amount,
min_checkout_items_quantity,
monkeypatch,
):
voucher = Voucher(
code="unique",
type=VoucherType.ENTIRE_ORDER,
discount_value_type=discount_type,
discount_value=discount_value,
min_spent=(
Money(min_spent_amount, "USD") if min_spent_amount is not None else None
),
min_checkout_items_quantity=min_checkout_items_quantity,
)
checkout = Mock(spec=Checkout, quantity=total_quantity)
subtotal = TaxedMoney(Money(total, "USD"), Money(total, "USD"))
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
with pytest.raises(NotApplicable):
get_voucher_discount_for_checkout(voucher, checkout)
def test_get_discount_for_checkout_shipping_voucher_not_applicable(
is_shipping_required,
shipping_method,
discount_value,
discount_type,
countries,
min_amount_spent,
subtotal,
error_msg,
):
subtotal_price = TaxedMoney(net=subtotal, gross=subtotal)
checkout = Mock(
get_subtotal=Mock(return_value=subtotal_price),
is_shipping_required=Mock(return_value=is_shipping_required),
shipping_method=shipping_method,
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
min_amount_spent=(Money(min_amount_spent, "USD")
if min_amount_spent is not None else None),
countries=countries,
)
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == error_msg
def test_get_discount_for_checkout_shipping_voucher_not_applicable(
is_shipping_required,
shipping_method,
discount_value,
discount_type,
countries,
min_amount_spent,
subtotal,
error_msg,
):
subtotal_price = TaxedMoney(net=subtotal, gross=subtotal)
checkout = Mock(
get_subtotal=Mock(return_value=subtotal_price),
is_shipping_required=Mock(return_value=is_shipping_required),
shipping_method=shipping_method,
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
min_amount_spent=(
Money(min_amount_spent, "USD") if min_amount_spent is not None else None
),
countries=countries,
)
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == error_msg
def test_get_voucher_discount_for_checkout_voucher_validation(
mock_validate_voucher, voucher, checkout_with_voucher):
get_voucher_discount_for_checkout(voucher, checkout_with_voucher)
manager = get_extensions_manager()
subtotal = manager.calculate_checkout_subtotal(checkout_with_voucher, [])
quantity = checkout_with_voucher.quantity
customer_email = checkout_with_voucher.get_customer_email()
mock_validate_voucher.assert_called_once_with(voucher, subtotal.gross,
quantity, customer_email)
def test_get_discount_for_checkout_value_voucher_not_applicable():
voucher = Voucher(code='unique',
type=VoucherType.VALUE,
discount_value_type=DiscountValueType.FIXED,
discount_value=10,
min_amount_spent=Money(100, 'USD'))
subtotal = TaxedMoney(net=Money(10, 'USD'), gross=Money(10, 'USD'))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert e.value.min_amount_spent == Money(100, 'USD')
def test_value_voucher_checkout_discount_not_applicable(settings):
voucher = Voucher(
code='unique', type=VoucherType.VALUE,
discount_value_type=DiscountValueType.FIXED,
discount_value=10,
limit=Money(100, 'USD'))
subtotal = TaxedMoney(net=Money(10, 'USD'), gross=Money(10, 'USD'))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert e.value.limit == Money(100, 'USD')
def test_get_discount_for_checkout_value_voucher_not_applicable():
voucher = Voucher(
code="unique",
type=VoucherType.ENTIRE_ORDER,
discount_value_type=DiscountValueType.FIXED,
discount_value=10,
min_amount_spent=Money(100, "USD"),
)
checkout = Mock(get_subtotal=Mock(return_value=Money(10, "USD")))
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert e.value.min_amount_spent == Money(100, "USD")
def test_get_discount_for_checkout_value_voucher_not_applicable():
voucher = Voucher(
code="unique",
type=VoucherType.VALUE,
discount_value_type=DiscountValueType.FIXED,
discount_value=10,
min_amount_spent=Money(100, "USD"),
)
subtotal = TaxedMoney(net=Money(10, "USD"), gross=Money(10, "USD"))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert e.value.min_amount_spent == Money(100, "USD")
def test_category_voucher_checkout_discount_not_applicable(
settings, monkeypatch):
monkeypatch.setattr(
'saleor.checkout.utils.get_category_variants_and_prices',
lambda cart, product: [])
voucher = Voucher(code='unique',
type=VoucherType.CATEGORY,
discount_value_type=DiscountValueType.FIXED,
discount_value=10)
checkout = Mock(cart=Mock())
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == 'This offer is only valid for selected items.'
def test_category_voucher_checkout_discount_not_applicable(
settings, monkeypatch):
monkeypatch.setattr(
'saleor.checkout.utils.get_category_variants_and_prices',
lambda cart, product: [])
voucher = Voucher(
code='unique', type=VoucherType.CATEGORY,
discount_value_type=DiscountValueType.FIXED,
discount_value=10)
checkout = Mock(cart=Mock())
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == 'This offer is only valid for selected items.'
def test_get_discount_for_checkout_product_voucher_not_applicable(monkeypatch):
monkeypatch.setattr(
'saleor.checkout.utils.get_prices_of_discounted_products',
lambda checkout, product: [])
voucher = Voucher(code='unique',
type=VoucherType.PRODUCT,
discount_value_type=DiscountValueType.FIXED,
discount_value=10)
voucher.save()
checkout = Mock()
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == 'This offer is only valid for selected items.'
def test_products_voucher_checkout_discount_not(
settings,
monkeypatch,
prices,
discount_value,
discount_type,
expected_value,
apply_once_per_order,
checkout_with_item,
):
monkeypatch.setattr(
"saleor.checkout.utils.get_prices_of_discounted_products",
lambda lines, discounted_products: (
TaxedMoney(net=Money(price, "USD"), gross=Money(price, "USD"))
for price in prices
),
)
voucher = Voucher(
code="unique",
type=VoucherType.PRODUCT,
discount_value_type=discount_type,
discount_value=discount_value,
apply_once_per_order=apply_once_per_order,
)
voucher.save()
checkout = checkout_with_item
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, "USD")
def test_shipping_voucher_checkout_discount_not_applicable(
settings, is_shipping_required, shipping_method, discount_value,
discount_type, apply_to, limit, subtotal, error_msg):
subtotal_price = TaxedMoney(net=subtotal, gross=subtotal)
checkout = Mock(is_shipping_required=is_shipping_required,
shipping_method=shipping_method,
get_subtotal=Mock(return_value=subtotal_price))
voucher = Voucher(code='unique',
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
limit=Money(limit, 'USD') if limit is not None else None,
apply_to=apply_to)
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == error_msg
def test_get_discount_for_checkout_value_voucher(
total,
min_spent_amount,
total_quantity,
min_checkout_items_quantity,
discount_value,
discount_value_type,
expected_value,
monkeypatch,
):
voucher = Voucher(
code="unique",
type=VoucherType.ENTIRE_ORDER,
discount_value_type=discount_value_type,
discount_value=discount_value,
min_spent=(
Money(min_spent_amount, "USD") if min_spent_amount is not None else None
),
min_checkout_items_quantity=min_checkout_items_quantity,
)
checkout = Mock(spec=Checkout, quantity=total_quantity)
subtotal = TaxedMoney(Money(total, "USD"), Money(total, "USD"))
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, "USD")
def test_get_discount_for_checkout_shipping_voucher(
shipping_cost,
shipping_country_code,
discount_value,
discount_type,
countries,
expected_value,
monkeypatch,
):
subtotal = TaxedMoney(Money(100, "USD"), Money(100, "USD"))
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
shipping_total = Money(shipping_cost, "USD")
checkout = Mock(
spec=Checkout,
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
get_shipping_price=Mock(return_value=shipping_total),
shipping_address=Mock(country=Country(shipping_country_code)),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
countries=countries,
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, "USD")
def test_specific_products_voucher_checkout_discount(
monkeypatch,
prices,
discount_value,
discount_type,
expected_value,
apply_once_per_order,
checkout_with_item,
):
discounts = []
monkeypatch.setattr(
"saleor.checkout.utils.get_prices_of_discounted_specific_product",
lambda lines, discounts, discounted_products:
(Money(price, "MXN") for price in prices),
)
voucher = Voucher(
code="unique",
type=VoucherType.SPECIFIC_PRODUCT,
discount_value_type=discount_type,
discount_value=discount_value,
apply_once_per_order=apply_once_per_order,
)
voucher.save()
checkout = checkout_with_item
discount = get_voucher_discount_for_checkout(voucher, checkout, discounts)
assert discount == Money(expected_value, "MXN")
def test_get_discount_for_checkout_shipping_voucher(
shipping_cost,
shipping_country_code,
discount_value,
discount_type,
countries,
expected_value,
):
subtotal = TaxedMoney(net=Money(100, "USD"), gross=Money(100, "USD"))
shipping_total = TaxedMoney(
net=Money(shipping_cost, "USD"), gross=Money(shipping_cost, "USD")
)
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country(shipping_country_code)),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
countries=countries,
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, "USD")
def test_get_discount_for_checkout_shipping_voucher_limited_countries():
subtotal = TaxedMoney(net=Money(100, 'USD'), gross=Money(100, 'USD'))
shipping_total = TaxedMoney(net=Money(10, 'USD'), gross=Money(10, 'USD'))
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country('PL')))
voucher = Voucher(code='unique',
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=['UK', 'DE'])
with pytest.raises(NotApplicable):
get_voucher_discount_for_checkout(voucher, checkout)
def test_get_discount_for_checkout_shipping_voucher(
shipping_cost,
shipping_country_code,
discount_value,
discount_type,
countries,
expected_value,
):
subtotal = TaxedMoney(net=Money(100, "USD"), gross=Money(100, "USD"))
shipping_total = TaxedMoney(net=Money(shipping_cost, "USD"),
gross=Money(shipping_cost, "USD"))
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country(shipping_country_code)),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
countries=countries,
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, "USD")
def test_get_discount_for_checkout_shipping_voucher_all_countries(monkeypatch):
subtotal = TaxedMoney(Money(100, "USD"), Money(100, "USD"))
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
shipping_total = TaxedMoney(Money(10, "USD"), Money(10, "USD"))
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_shipping_price",
lambda checkout, discounts: shipping_total,
)
checkout = Mock(
spec=Checkout,
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country("PL")),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=[],
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(5, "USD")
def test_products_voucher_checkout_discount_not(
settings,
monkeypatch,
prices,
discount_value,
discount_type,
expected_value,
apply_once_per_order,
checkout_with_item,
):
monkeypatch.setattr(
"saleor.checkout.utils.get_prices_of_discounted_products",
lambda lines, discounted_products: (
TaxedMoney(net=Money(price, "USD"), gross=Money(price, "USD"))
for price in prices
),
)
voucher = Voucher(
code="unique",
type=VoucherType.PRODUCT,
discount_value_type=discount_type,
discount_value=discount_value,
apply_once_per_order=apply_once_per_order,
)
voucher.save()
checkout = checkout_with_item
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, "USD")
def test_shipping_voucher_checkout_discount_not_applicable(
settings, is_shipping_required, shipping_method, discount_value,
discount_type, apply_to, limit, subtotal, error_msg):
subtotal_price = TaxedMoney(net=subtotal, gross=subtotal)
checkout = Mock(
is_shipping_required=is_shipping_required,
shipping_method=shipping_method,
get_subtotal=Mock(return_value=subtotal_price))
voucher = Voucher(
code='unique', type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
limit=Money(limit, 'USD') if limit is not None else None,
apply_to=apply_to)
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == error_msg
def test_get_discount_for_checkout_collection_voucher_not_applicable(monkeypatch):
monkeypatch.setattr(
"saleor.checkout.utils.get_prices_of_products_in_discounted_collections", # noqa
lambda checkout, product: [],
)
voucher = Voucher(
code="unique",
type=VoucherType.COLLECTION,
discount_value_type=DiscountValueType.FIXED,
discount_value=10,
)
voucher.save()
checkout = Mock()
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == "This offer is only valid for selected items."
def test_get_discount_for_checkout_collection_voucher_not_applicable(
monkeypatch):
monkeypatch.setattr(
"saleor.checkout.utils.get_prices_of_products_in_discounted_collections", # noqa
lambda checkout, product: [],
)
voucher = Voucher(
code="unique",
type=VoucherType.COLLECTION,
discount_value_type=DiscountValueType.FIXED,
discount_value=10,
)
voucher.save()
checkout = Mock()
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == "This offer is only valid for selected items."
def test_get_discount_for_checkout_specific_products_voucher_not_applicable(
monkeypatch,
total,
total_quantity,
discount_value,
discount_type,
min_spent_amount,
min_checkout_items_quantity,
):
discounts = []
monkeypatch.setattr(
"saleor.checkout.utils.get_prices_of_discounted_specific_product",
lambda checkout, discounts, product: [],
)
monkeypatch.setattr(
"saleor.checkout.calculations.checkout_shipping_price",
lambda _: TaxedMoney(Money(0, "USD"), Money(0, "USD")),
)
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: TaxedMoney(
Money(total, "USD"), Money(total, "USD")
),
)
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_subtotal",
lambda checkout, discounts: TaxedMoney(
Money(total, "USD"), Money(total, "USD")
),
)
voucher = Voucher(
code="unique",
type=VoucherType.SPECIFIC_PRODUCT,
discount_value_type=discount_type,
discount_value=discount_value,
min_spent=(
Money(min_spent_amount, "USD") if min_spent_amount is not None else None
),
min_checkout_items_quantity=min_checkout_items_quantity,
)
checkout = Mock(quantity=total_quantity, spec=Checkout)
with pytest.raises(NotApplicable):
get_voucher_discount_for_checkout(voucher, checkout, discounts)
def test_get_discount_for_checkout_shipping_voucher_limited_countries():
subtotal = TaxedMoney(net=Money(100, "USD"), gross=Money(100, "USD"))
shipping_total = TaxedMoney(net=Money(10, "USD"), gross=Money(10, "USD"))
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country("PL")),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=["UK", "DE"],
)
with pytest.raises(NotApplicable):
get_voucher_discount_for_checkout(voucher, checkout)
def test_get_discount_for_checkout_shipping_voucher_not_applicable(
is_shipping_required,
shipping_method,
discount_value,
discount_type,
countries,
min_spent_amount,
min_checkout_items_quantity,
subtotal,
total_quantity,
error_msg,
monkeypatch,
):
monkeypatch.setattr(
"saleor.checkout.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
checkout = Mock(
is_shipping_required=Mock(return_value=is_shipping_required),
shipping_method=shipping_method,
quantity=total_quantity,
spec=Checkout,
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
min_spent=(
Money(min_spent_amount, "USD") if min_spent_amount is not None else None
),
min_checkout_items_quantity=min_checkout_items_quantity,
countries=countries,
)
with pytest.raises(NotApplicable) as e:
get_voucher_discount_for_checkout(voucher, checkout)
assert str(e.value) == error_msg
def test_value_voucher_checkout_discount(
settings, total, discount_value, discount_type, limit, expected_value):
voucher = Voucher(
code='unique', type=VoucherType.VALUE,
discount_value_type=discount_type,
discount_value=discount_value,
limit=Money(limit, 'USD') if limit is not None else None)
subtotal = TaxedMoney(net=Money(total, 'USD'), gross=Money(total, 'USD'))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, 'USD')
def test_value_voucher_checkout_discount(settings, total, discount_value,
discount_type, limit, expected_value):
voucher = Voucher(code='unique',
type=VoucherType.VALUE,
discount_value_type=discount_type,
discount_value=discount_value,
limit=Money(limit, 'USD') if limit is not None else None)
subtotal = TaxedMoney(net=Money(total, 'USD'), gross=Money(total, 'USD'))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, 'USD')
def test_get_discount_for_checkout_shipping_voucher_limited_countries(monkeypatch):
subtotal = TaxedMoney(net=Money(100, "USD"), gross=Money(100, "USD"))
shipping_total = TaxedMoney(net=Money(10, "USD"), gross=Money(10, "USD"))
monkeypatch.setattr(
"saleor.discount.utils.calculations.checkout_subtotal",
lambda checkout, discounts: subtotal,
)
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country("PL")),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=["UK", "DE"],
)
with pytest.raises(NotApplicable):
get_voucher_discount_for_checkout(voucher, checkout)
def test_get_discount_for_checkout_value_voucher(total, discount_value,
discount_type,
min_amount_spent,
discount_amount):
voucher = Voucher(
code="unique",
type=VoucherType.ENTIRE_ORDER,
discount_value_type=discount_type,
discount_value=discount_value,
min_amount_spent=(Money(min_amount_spent, "USD")
if min_amount_spent is not None else None),
)
checkout = Mock(get_subtotal=Mock(return_value=Money(total, "USD")))
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(discount_amount, "USD")
def test_get_discount_for_checkout_value_voucher(total, discount_value,
discount_type,
min_amount_spent,
discount_amount):
voucher = Voucher(
code='unique',
type=VoucherType.VALUE,
discount_value_type=discount_type,
discount_value=discount_value,
min_amount_spent=(Money(min_amount_spent, 'USD')
if min_amount_spent is not None else None))
subtotal = TaxedMoney(net=Money(total, 'USD'), gross=Money(total, 'USD'))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(discount_amount, 'USD')
def test_products_voucher_checkout_discount_not(settings, monkeypatch, prices,
discount_value, discount_type,
apply_to, expected_value):
monkeypatch.setattr(
'saleor.checkout.utils.get_product_variants_and_prices',
lambda cart, product:
((None, TaxedMoney(net=Money(price, 'USD'), gross=Money(price, 'USD')))
for price in prices))
voucher = Voucher(code='unique',
type=VoucherType.PRODUCT,
discount_value_type=discount_type,
discount_value=discount_value,
apply_to=apply_to)
checkout = Mock(cart=Mock())
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, 'USD')
def test_get_discount_for_checkout_value_voucher(
total, discount_value, discount_type, min_amount_spent, discount_amount
):
voucher = Voucher(
code="unique",
type=VoucherType.VALUE,
discount_value_type=discount_type,
discount_value=discount_value,
min_amount_spent=(
Money(min_amount_spent, "USD") if min_amount_spent is not None else None
),
)
subtotal = TaxedMoney(net=Money(total, "USD"), gross=Money(total, "USD"))
checkout = Mock(get_subtotal=Mock(return_value=subtotal))
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(discount_amount, "USD")
def test_get_discount_for_checkout_shipping_voucher_all_countries():
subtotal = TaxedMoney(net=Money(100, 'USD'), gross=Money(100, 'USD'))
shipping_total = TaxedMoney(net=Money(10, 'USD'), gross=Money(10, 'USD'))
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country('PL')))
voucher = Voucher(code='unique',
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=[])
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(5, 'USD')
def test_get_discount_for_checkout_specific_products_voucher(
checkout_with_items,
product_list,
discount_value,
discount_type,
apply_once_per_order,
discount_amount,
):
voucher = Voucher.objects.create(
code="unique",
type=VoucherType.SPECIFIC_PRODUCT,
discount_value_type=discount_type,
discount_value=discount_value,
apply_once_per_order=apply_once_per_order,
)
for product in product_list:
voucher.products.add(product)
discount = get_voucher_discount_for_checkout(voucher, checkout_with_items)
assert discount == Money(discount_amount, "USD")
def test_shipping_voucher_checkout_discount(
settings, shipping_cost, shipping_country_code, discount_value,
discount_type, apply_to, expected_value):
subtotal = TaxedMoney(net=Money(100, 'USD'), gross=Money(100, 'USD'))
shipping_total = TaxedMoney(
net=Money(shipping_cost, 'USD'), gross=Money(shipping_cost, 'USD'))
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=True, shipping_method=Mock(
price=Money(shipping_cost, 'USD'),
country_code=shipping_country_code,
get_total_price=Mock(return_value=shipping_total)))
voucher = Voucher(
code='unique', type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
apply_to=apply_to,
limit=None)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, 'USD')
def test_get_discount_for_checkout_shipping_voucher_all_countries():
subtotal = TaxedMoney(net=Money(100, "USD"), gross=Money(100, "USD"))
shipping_total = TaxedMoney(net=Money(10, "USD"), gross=Money(10, "USD"))
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
shipping_address=Mock(country=Country("PL")),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=[],
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(5, "USD")
def test_get_discount_for_checkout_shipping_voucher_all_countries():
subtotal = Money(100, "USD")
shipping_total = Money(10, "USD")
checkout = Mock(
get_subtotal=Mock(return_value=subtotal),
is_shipping_required=Mock(return_value=True),
shipping_method=Mock(get_total=Mock(return_value=shipping_total)),
get_shipping_price=Mock(return_value=shipping_total),
shipping_address=Mock(country=Country("PL")),
)
voucher = Voucher(
code="unique",
type=VoucherType.SHIPPING,
discount_value_type=DiscountValueType.PERCENTAGE,
discount_value=50,
countries=[],
)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(5, "USD")
def test_shipping_voucher_checkout_discount(settings, shipping_cost,
shipping_country_code,
discount_value, discount_type,
apply_to, expected_value):
subtotal = TaxedMoney(net=Money(100, 'USD'), gross=Money(100, 'USD'))
shipping_total = TaxedMoney(net=Money(shipping_cost, 'USD'),
gross=Money(shipping_cost, 'USD'))
checkout = Mock(get_subtotal=Mock(return_value=subtotal),
is_shipping_required=True,
shipping_method=Mock(
price=Money(shipping_cost, 'USD'),
country_code=shipping_country_code,
get_total_price=Mock(return_value=shipping_total)))
voucher = Voucher(code='unique',
type=VoucherType.SHIPPING,
discount_value_type=discount_type,
discount_value=discount_value,
apply_to=apply_to,
limit=None)
discount = get_voucher_discount_for_checkout(voucher, checkout)
assert discount == Money(expected_value, 'USD')
