def test_create_order_doesnt_duplicate_order(checkout_with_item, customer_user,
shipping_method):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
with patch.object(checkout, "delete") as mocked_delete:
order_1 = create_order(checkout,
tracking_code="",
discounts=None,
taxes=None,
user=customer_user)
assert order_1.checkout_token == checkout.token
order_2 = create_order(checkout,
tracking_code="",
discounts=None,
taxes=None,
user=customer_user)
assert order_1.pk == order_2.pk
assert mocked_delete.call_count == 1
def test_create_order_doesnt_duplicate_order(
checkout_with_item, customer_user, shipping_method
):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
order_data = prepare_order_data(checkout=checkout, tracking_code="", discounts=None)
order_1 = create_order(
checkout=checkout,
order_data=order_data,
user=customer_user,
redirect_url="https://www.example.com",
)
assert order_1.checkout_token == checkout.token
order_2 = create_order(
checkout=checkout,
order_data=order_data,
user=customer_user,
redirect_url="https://www.example.com",
)
assert order_1.pk == order_2.pk
def test_create_order_insufficient_stock(request_cart, customer_user,
product_without_shipping):
variant = product_without_shipping.variants.get()
add_variant_to_cart(request_cart, variant, 10, check_quantity=False)
request_cart.user = customer_user
request_cart.billing_address = customer_user.default_billing_address
request_cart.save()
with pytest.raises(InsufficientStock):
create_order(request_cart, 'tracking_code', discounts=None, taxes=None)
def test_create_order_insufficient_stock(
request_cart, customer_user, product_without_shipping):
variant = product_without_shipping.variants.get()
add_variant_to_cart(request_cart, variant, 10, check_quantity=False)
request_cart.user = customer_user
request_cart.billing_address = customer_user.default_billing_address
request_cart.save()
with pytest.raises(InsufficientStock):
create_order(
request_cart, 'tracking_code', discounts=None, taxes=None)
def test_create_order_doesnt_duplicate_order(cart_with_item, customer_user,
shipping_method):
cart = cart_with_item
cart.user = customer_user
cart.billing_address = customer_user.default_billing_address
cart.shipping_address = customer_user.default_billing_address
cart.shipping_method = shipping_method
cart.save()
order_1 = create_order(cart, tracking_code='', discounts=None, taxes=None)
assert order_1.checkout_token == cart_with_item.token
order_2 = create_order(cart, tracking_code='', discounts=None, taxes=None)
assert order_1.pk == order_2.pk
def test_create_order_doesnt_duplicate_order(
cart_with_item, customer_user, shipping_method):
cart = cart_with_item
cart.user = customer_user
cart.billing_address = customer_user.default_billing_address
cart.shipping_address = customer_user.default_billing_address
cart.shipping_method = shipping_method
cart.save()
order_1 = create_order(cart, tracking_code='', discounts=None, taxes=None)
assert order_1.checkout_token == cart_with_item.token
order_2 = create_order(cart, tracking_code='', discounts=None, taxes=None)
assert order_1.pk == order_2.pk
def test_create_order_creates_expected_events(request_checkout_with_item,
customer_user, shipping_method,
is_anonymous_user):
checkout = request_checkout_with_item
checkout_user = None if is_anonymous_user else customer_user
# Ensure not events are existing prior
assert not OrderEvent.objects.exists()
assert not CustomerEvent.objects.exists()
# Prepare valid checkout
checkout.user = checkout_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_shipping_address
checkout.shipping_method = shipping_method
checkout.save()
# Place checkout
order = create_order(
checkout=checkout,
order_data=prepare_order_data(checkout=checkout,
tracking_code="tracking_code",
discounts=None,
taxes=None),
user=customer_user if not is_anonymous_user else AnonymousUser(),
)
# Ensure only two events were created, and retrieve them
placement_event, email_sent_event = order.events.all() # type: OrderEvent
# Ensure the correct order event was created
assert placement_event.type == OrderEvents.PLACED # is the event the expected type
assert placement_event.user == checkout_user # is the user anonymous/ the customer
assert placement_event.order is order # is the associated backref order valid
assert placement_event.date # ensure a date was set
assert not placement_event.parameters # should not have any additional parameters
# Ensure the correct email sent event was created
assert email_sent_event.type == OrderEvents.EMAIL_SENT # should be email sent event
assert email_sent_event.user == checkout_user # ensure the user is none or valid
assert email_sent_event.order is order # ensure the mail event is related to order
assert email_sent_event.date # ensure a date was set
assert email_sent_event.parameters == { # ensure the correct parameters were set
"email": order.get_user_current_email(),
"email_type": OrderEventsEmails.ORDER,
}
# Check no event was created if the user was anonymous
if is_anonymous_user:
assert not CustomerEvent.objects.exists(
) # should not have created any event
return # we are done testing as the user is anonymous
# Ensure the correct customer event was created if the user was not anonymous
placement_event = customer_user.events.get() # type: CustomerEvent
assert placement_event.type == CustomerEvents.PLACED_ORDER # check the event type
assert placement_event.user == customer_user # check the backref is valid
assert placement_event.order == order # check the associated order is valid
assert placement_event.date # ensure a date was set
assert not placement_event.parameters # should not have any additional parameters
def test_create_order_with_gift_card_partial_use(
checkout_with_item, gift_card_used, customer_user, shipping_method
):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
price_without_gift_card = calculations.checkout_total(checkout)
gift_card_balance_before_order = gift_card_used.current_balance_amount
checkout.gift_cards.add(gift_card_used)
checkout.save()
order = create_order(
checkout=checkout,
order_data=prepare_order_data(
checkout=checkout, tracking_code="tracking_code", discounts=None
),
user=customer_user,
redirect_url="https://www.example.com",
)
gift_card_used.refresh_from_db()
expected_old_balance = (
price_without_gift_card.gross.amount + gift_card_used.current_balance_amount
)
assert order.gift_cards.count() > 0
assert order.total == zero_taxed_money()
assert gift_card_balance_before_order == expected_old_balance
def test_note_in_created_order(request_cart_with_item, address):
request_cart_with_item.shipping_address = address
request_cart_with_item.note = 'test_note'
request_cart_with_item.save()
order = create_order(
request_cart_with_item, 'tracking_code', discounts=None, taxes=None)
assert order.customer_note == request_cart_with_item.note
def test_create_order_with_gift_card(checkout_with_gift_card, customer_user,
shipping_method, is_anonymous_user):
checkout_user = None if is_anonymous_user else customer_user
checkout = checkout_with_gift_card
checkout.user = checkout_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
total_gross_without_gift_cards = (checkout.get_subtotal() +
checkout.get_shipping_price(None) -
checkout.discount_amount).gross
gift_cards_balance = checkout.get_total_gift_cards_balance()
order = create_order(
checkout=checkout,
order_data=prepare_order_data(checkout=checkout,
tracking_code="tracking_code",
discounts=None,
taxes=None),
user=customer_user if not is_anonymous_user else AnonymousUser(),
)
assert order.gift_cards.count() > 0
assert order.gift_cards.first().current_balance.amount == 0
assert order.total.gross == (total_gross_without_gift_cards -
gift_cards_balance)
def test_create_order_with_gift_card(
checkout_with_gift_card, customer_user, shipping_method, is_anonymous_user
):
checkout_user = None if is_anonymous_user else customer_user
checkout = checkout_with_gift_card
checkout.user = checkout_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
subtotal = calculations.checkout_subtotal(checkout)
shipping_price = calculations.checkout_shipping_price(checkout)
total_gross_without_gift_cards = (
subtotal.gross + shipping_price.gross - checkout.discount
)
gift_cards_balance = checkout.get_total_gift_cards_balance()
order = create_order(
checkout=checkout,
order_data=prepare_order_data(
checkout=checkout, tracking_code="tracking_code", discounts=None
),
user=customer_user if not is_anonymous_user else AnonymousUser(),
redirect_url="https://www.example.com",
)
assert order.gift_cards.count() == 1
assert order.gift_cards.first().current_balance.amount == 0
assert order.total.gross == (total_gross_without_gift_cards - gift_cards_balance)
def test_create_order_with_gift_card_partial_use(checkout_with_item,
gift_card_used, customer_user,
shipping_method):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
price_without_gift_card = checkout.get_total()
gift_card_balance_before_order = gift_card_used.current_balance
checkout.gift_cards.add(gift_card_used)
checkout.save()
order = create_order(
checkout=checkout,
order_data=prepare_order_data(checkout=checkout,
tracking_code="tracking_code",
discounts=None,
taxes=None),
user=customer_user,
)
gift_card_used.refresh_from_db()
assert order.gift_cards.count() > 0
assert order.total == ZERO_TAXED_MONEY
assert (gift_card_balance_before_order == (
price_without_gift_card + gift_card_used.current_balance).gross.amount)
def test_note_in_created_order_empty_note(request_cart_with_item, address):
request_cart_with_item.shipping_address = address
request_cart_with_item.note = ''
request_cart_with_item.save()
order = create_order(
request_cart_with_item, 'tracking_code', discounts=None, taxes=None)
assert not order.notes.all()
def test_note_in_created_order(request_cart_with_item, address):
request_cart_with_item.shipping_address = address
request_cart_with_item.note = 'test_note'
request_cart_with_item.save()
order = create_order(
request_cart_with_item, 'tracking_code', discounts=None, taxes=None)
assert order.notes.filter(content='test_note').exists()
def test_order_payment_flow(request_cart_with_item, client, address,
shipping_method):
request_cart_with_item.shipping_address = address
request_cart_with_item.billing_address = address.get_copy()
request_cart_with_item.email = '*****@*****.**'
request_cart_with_item.shipping_method = (
shipping_method.price_per_country.first())
request_cart_with_item.save()
order = create_order(request_cart_with_item,
'tracking_code',
discounts=None,
taxes=None)
# Select payment method
url = reverse('order:payment', kwargs={'token': order.token})
data = {'method': 'default'}
response = client.post(url, data, follow=True)
assert len(response.redirect_chain) == 1
assert response.status_code == 200
redirect_url = reverse('order:payment',
kwargs={
'token': order.token,
'variant': 'default'
})
assert response.request['PATH_INFO'] == redirect_url
# Go to payment details page, enter payment data
data = {
'status': PaymentStatus.PREAUTH,
'fraud_status': FraudStatus.UNKNOWN,
'gateway_response': '3ds-disabled',
'verification_result': 'waiting'
}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse('order:payment-success',
kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
# Complete payment, go to checkout success page
data = {'status': 'ok'}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse('order:checkout-success',
kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
# Assert that payment object was created and contains correct data
payment = order.payments.all()[0]
assert payment.total == order.total.gross.amount
assert payment.tax == order.total.tax.amount
assert payment.currency == order.total.currency
assert payment.delivery == order.shipping_price.net.amount
assert len(payment.get_purchased_items()) == len(order.lines.all())
def test_create_order_creates_expected_events(
request_checkout_with_item, customer_user, shipping_method, is_anonymous_user
):
checkout = request_checkout_with_item
checkout_user = None if is_anonymous_user else customer_user
# Ensure not events are existing prior
assert not OrderEvent.objects.exists()
assert not CustomerEvent.objects.exists()
# Prepare valid checkout
checkout.user = checkout_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_shipping_address
checkout.shipping_method = shipping_method
checkout.save()
# Place checkout
order = create_order(
checkout,
"tracking_code",
discounts=None,
taxes=None,
user=customer_user if not is_anonymous_user else AnonymousUser(),
)
# Ensure only two events were created, and retrieve them
placement_event, email_sent_event = order.events.all() # type: OrderEvent
# Ensure the correct order event was created
assert placement_event.type == OrderEvents.PLACED # is the event the expected type
assert placement_event.user == checkout_user # is the user anonymous/ the customer
assert placement_event.order is order # is the associated backref order valid
assert placement_event.date # ensure a date was set
assert not placement_event.parameters # should not have any additional parameters
# Ensure the correct email sent event was created
assert email_sent_event.type == OrderEvents.EMAIL_SENT # should be email sent event
assert email_sent_event.user == checkout_user # ensure the user is none or valid
assert email_sent_event.order is order # ensure the mail event is related to order
assert email_sent_event.date # ensure a date was set
assert email_sent_event.parameters == { # ensure the correct parameters were set
"email": order.get_user_current_email(),
"email_type": OrderEventsEmails.ORDER,
}
# Check no event was created if the user was anonymous
if is_anonymous_user:
assert not CustomerEvent.objects.exists() # should not have created any event
return # we are done testing as the user is anonymous
# Ensure the correct customer event was created if the user was not anonymous
placement_event = customer_user.events.get() # type: CustomerEvent
assert placement_event.type == CustomerEvents.PLACED_ORDER # check the event type
assert placement_event.user == customer_user # check the backref is valid
assert placement_event.order == order # check the associated order is valid
assert placement_event.date # ensure a date was set
assert not placement_event.parameters # should not have any additional parameters
def test_note_in_created_order_empty_note(request_cart_with_item, address):
request_cart_with_item.shipping_address = address
request_cart_with_item.note = ''
request_cart_with_item.save()
order = create_order(request_cart_with_item,
'tracking_code',
discounts=None,
taxes=None)
assert not order.notes.all()
def test_note_in_created_order(request_cart_with_item, address):
request_cart_with_item.shipping_address = address
request_cart_with_item.note = 'test_note'
request_cart_with_item.save()
order = create_order(request_cart_with_item,
'tracking_code',
discounts=None,
taxes=None)
assert order.notes.filter(content='test_note').exists()
def test_note_in_created_order(request_checkout_with_item, address):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.note = 'test_note'
request_checkout_with_item.save()
order = create_order(request_checkout_with_item,
'tracking_code',
discounts=None,
taxes=None)
assert order.customer_note == request_checkout_with_item.note
def test_order_payment_flow(request_checkout_with_item, client, address,
customer_user, shipping_zone, settings):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.billing_address = address.get_copy()
request_checkout_with_item.email = "*****@*****.**"
request_checkout_with_item.shipping_method = shipping_zone.shipping_methods.first(
)
request_checkout_with_item.save()
order = create_order(
checkout=request_checkout_with_item,
order_data=prepare_order_data(
checkout=request_checkout_with_item,
tracking_code="tracking_code",
discounts=None,
taxes=None,
),
user=customer_user,
)
# Select payment
url = reverse("order:payment", kwargs={"token": order.token})
data = {"gateway": settings.DUMMY}
response = client.post(url, data, follow=True)
assert len(response.redirect_chain) == 1
assert response.status_code == 200
redirect_url = reverse("order:payment",
kwargs={
"token": order.token,
"gateway": settings.DUMMY
})
assert response.request["PATH_INFO"] == redirect_url
# Go to payment details page, enter payment data
data = {
"gateway": settings.DUMMY,
"is_active": True,
"total": order.total.gross.amount,
"currency": order.total.gross.currency,
"charge_status": ChargeStatus.FULLY_CHARGED,
}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse("order:payment-success",
kwargs={"token": order.token})
assert get_redirect_location(response) == redirect_url
# Assert that payment object was created and contains correct data
payment = order.payments.all()[0]
assert payment.total == order.total.gross.amount
assert payment.currency == order.total.gross.currency
assert payment.transactions.count() == 1
assert payment.transactions.last().kind == "capture"
def test_note_in_created_order(request_checkout_with_item, address, customer_user):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.note = "test_note"
request_checkout_with_item.save()
order = create_order(
request_checkout_with_item,
"tracking_code",
discounts=None,
taxes=None,
user=customer_user,
)
assert order.customer_note == request_checkout_with_item.note
def test_create_order_doesnt_duplicate_order(checkout_with_item, customer_user,
shipping_method):
checkout = checkout_with_item
checkout.user = customer_user
checkout.address = customer_user.default_address
checkout.shipping_method = shipping_method
checkout.save()
order_data = prepare_order_data(checkout=checkout,
tracking_code="",
discounts=None)
order_1 = create_order(checkout=checkout,
order_data=order_data,
user=customer_user)
assert order_1.checkout_token == checkout.token
order_2 = create_order(checkout=checkout,
order_data=order_data,
user=customer_user)
assert order_1.pk == order_2.pk
def test_order_payment_flow(
request_cart_with_item, client, address, shipping_method):
request_cart_with_item.shipping_address = address
request_cart_with_item.billing_address = address.get_copy()
request_cart_with_item.email = '*****@*****.**'
request_cart_with_item.shipping_method = (
shipping_method.price_per_country.first())
request_cart_with_item.save()
order = create_order(
request_cart_with_item, 'tracking_code', discounts=None, taxes=None)
# Select payment method
url = reverse('order:payment', kwargs={'token': order.token})
data = {'method': 'default'}
response = client.post(url, data, follow=True)
assert len(response.redirect_chain) == 1
assert response.status_code == 200
redirect_url = reverse(
'order:payment', kwargs={'token': order.token, 'variant': 'default'})
assert response.request['PATH_INFO'] == redirect_url
# Go to payment details page, enter payment data
data = {
'status': PaymentStatus.PREAUTH,
'fraud_status': FraudStatus.UNKNOWN,
'gateway_response': '3ds-disabled',
'verification_result': 'waiting'}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse(
'order:payment-success', kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
# Complete payment, go to checkout success page
data = {'status': 'ok'}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse(
'order:checkout-success', kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
# Assert that payment object was created and contains correct data
payment = order.payments.all()[0]
assert payment.total == order.total.gross.amount
assert payment.tax == order.total.tax.amount
assert payment.currency == order.total.currency
assert payment.delivery == order.shipping_price.net.amount
assert len(payment.get_purchased_items()) == len(order.lines.all())
def test_note_in_created_order(request_checkout_with_item, address,
customer_user):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.note = "test_note"
request_checkout_with_item.save()
order = create_order(
request_checkout_with_item,
"tracking_code",
discounts=None,
taxes=None,
user=customer_user,
)
assert order.customer_note == request_checkout_with_item.note
def test_create_order_doesnt_duplicate_order(
checkout_with_item, customer_user, shipping_method
):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
with patch.object(checkout, "delete") as mocked_delete:
order_1 = create_order(
checkout, tracking_code="", discounts=None, taxes=None, user=customer_user
)
assert order_1.checkout_token == checkout.token
order_2 = create_order(
checkout, tracking_code="", discounts=None, taxes=None, user=customer_user
)
assert order_1.pk == order_2.pk
assert mocked_delete.call_count == 1
def test_order_payment_flow(request_checkout_with_item, client, address,
shipping_zone, settings):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.billing_address = address.get_copy()
request_checkout_with_item.email = '*****@*****.**'
request_checkout_with_item.shipping_method = (
shipping_zone.shipping_methods.first())
request_checkout_with_item.save()
order = create_order(request_checkout_with_item,
'tracking_code',
discounts=None,
taxes=None)
# Select payment
url = reverse('order:payment', kwargs={'token': order.token})
data = {'gateway': settings.DUMMY}
response = client.post(url, data, follow=True)
assert len(response.redirect_chain) == 1
assert response.status_code == 200
redirect_url = reverse('order:payment',
kwargs={
'token': order.token,
'gateway': settings.DUMMY
})
assert response.request['PATH_INFO'] == redirect_url
# Go to payment details page, enter payment data
data = {
'gateway': settings.DUMMY,
'is_active': True,
'total': order.total.gross.amount,
'currency': order.total.gross.currency,
'charge_status': ChargeStatus.FULLY_CHARGED
}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse('order:payment-success',
kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
# Assert that payment object was created and contains correct data
payment = order.payments.all()[0]
assert payment.total == order.total.gross.amount
assert payment.currency == order.total.gross.currency
assert payment.transactions.count() == 2
assert payment.transactions.first().kind == 'auth'
assert payment.transactions.last().kind == 'capture'
def test_order_payment_flow(
request_checkout_with_item, client, address, customer_user, shipping_zone, settings
):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.billing_address = address.get_copy()
request_checkout_with_item.email = "*****@*****.**"
request_checkout_with_item.shipping_method = shipping_zone.shipping_methods.first()
request_checkout_with_item.save()
order = create_order(
request_checkout_with_item,
"tracking_code",
discounts=None,
taxes=None,
user=customer_user,
)
# Select payment
url = reverse("order:payment", kwargs={"token": order.token})
data = {"gateway": settings.DUMMY}
response = client.post(url, data, follow=True)
assert len(response.redirect_chain) == 1
assert response.status_code == 200
redirect_url = reverse(
"order:payment", kwargs={"token": order.token, "gateway": settings.DUMMY}
)
assert response.request["PATH_INFO"] == redirect_url
# Go to payment details page, enter payment data
data = {
"gateway": settings.DUMMY,
"is_active": True,
"total": order.total.gross.amount,
"currency": order.total.gross.currency,
"charge_status": ChargeStatus.FULLY_CHARGED,
}
response = client.post(redirect_url, data)
assert response.status_code == 302
redirect_url = reverse("order:payment-success", kwargs={"token": order.token})
assert get_redirect_location(response) == redirect_url
# Assert that payment object was created and contains correct data
payment = order.payments.all()[0]
assert payment.total == order.total.gross.amount
assert payment.currency == order.total.gross.currency
assert payment.transactions.count() == 1
assert payment.transactions.last().kind == "capture"
def test_note_in_created_order(request_checkout_with_item, address,
customer_user):
request_checkout_with_item.address = address
request_checkout_with_item.note = "test_note"
request_checkout_with_item.save()
order = create_order(
checkout=request_checkout_with_item,
order_data=prepare_order_data(
checkout=request_checkout_with_item,
tracking_code="tracking_code",
discounts=None,
),
user=customer_user,
)
assert order.customer_note == request_checkout_with_item.note
def test_note_in_created_order(request_checkout_with_item, address, customer_user):
request_checkout_with_item.shipping_address = address
request_checkout_with_item.note = "test_note"
request_checkout_with_item.save()
order = create_order(
checkout=request_checkout_with_item,
order_data=prepare_order_data(
checkout=request_checkout_with_item,
tracking_code="tracking_code",
discounts=None,
),
user=customer_user,
redirect_url="https://www.example.com",
)
assert order.customer_note == request_checkout_with_item.note
def test_create_order_with_many_gift_cards(
checkout_with_item,
gift_card_created_by_staff,
gift_card,
customer_user,
shipping_method,
):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
price_without_gift_card = calculations.checkout_total(
checkout=checkout, lines=list(checkout)
)
gift_cards_balance_before_order = (
gift_card_created_by_staff.current_balance.amount
+ gift_card.current_balance.amount
)
checkout.gift_cards.add(gift_card_created_by_staff)
checkout.gift_cards.add(gift_card)
checkout.save()
order = create_order(
checkout=checkout,
order_data=prepare_order_data(
checkout=checkout,
lines=list(checkout),
tracking_code="tracking_code",
discounts=None,
),
user=customer_user,
redirect_url="https://www.example.com",
)
gift_card_created_by_staff.refresh_from_db()
gift_card.refresh_from_db()
zero_price = zero_money()
assert order.gift_cards.count() > 0
assert gift_card_created_by_staff.current_balance == zero_price
assert gift_card.current_balance == zero_price
assert price_without_gift_card.gross.amount == (
gift_cards_balance_before_order + order.total.gross.amount
)
def test_create_order_with_many_gift_cards(
checkout_with_item,
gift_card_created_by_staff,
gift_card,
customer_user,
shipping_method,
):
checkout = checkout_with_item
checkout.user = customer_user
checkout.billing_address = customer_user.default_billing_address
checkout.shipping_address = customer_user.default_billing_address
checkout.shipping_method = shipping_method
checkout.save()
checkout_total = checkout.get_total()
price_without_gift_card = TaxedMoney(net=checkout_total,
gross=checkout_total)
gift_cards_balance_befor_order = (
gift_card_created_by_staff.current_balance + gift_card.current_balance)
checkout.gift_cards.add(gift_card_created_by_staff)
checkout.gift_cards.add(gift_card)
checkout.save()
order = create_order(
checkout=checkout,
order_data=prepare_order_data(checkout=checkout,
tracking_code="tracking_code",
discounts=None),
user=customer_user,
)
gift_card_created_by_staff.refresh_from_db()
gift_card.refresh_from_db()
zero_price = zero_money()
assert order.gift_cards.count() > 0
assert gift_card_created_by_staff.current_balance == zero_price
assert gift_card.current_balance == zero_price
assert price_without_gift_card.gross.amount == (
gift_cards_balance_befor_order + order.total.gross.amount)