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_view_fulfill_order_lines_with_empty_quantity(admin_client, order_with_lines):
url = reverse(
"dashboard:fulfill-order-lines", kwargs={"order_pk": order_with_lines.pk}
)
data = {
"csrfmiddlewaretoken": "hello",
"form-INITIAL_FORMS": "0",
"form-MAX_NUM_FORMS": "1000",
"form-MIN_NUM_FORMS": "0",
"form-TOTAL_FORMS": order_with_lines.lines.count(),
"send_mail": "on",
"tracking_number": "",
}
for i, line in enumerate(order_with_lines):
data["form-{}-order_line".format(i)] = line.pk
data["form-{}-quantity".format(i)] = line.quantity_unfulfilled
# Set first order line's fulfill quantity to 0
data["form-0-quantity"] = 0
response = admin_client.post(url, data)
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
"dashboard:order-details", kwargs={"order_pk": order_with_lines.pk}
)
order_with_lines.refresh_from_db()
assert not order_with_lines.lines.all()[0].quantity_unfulfilled == 0
for line in order_with_lines.lines.all()[1:]:
assert line.quantity_unfulfilled == 0
def test_view_product_type_edit_to_no_variants_valid(admin_client, product):
product_type = ProductType.objects.create(
name="New product type", has_variants=True
)
product.product_type = product_type
product.save()
url = reverse("dashboard:product-type-update", kwargs={"pk": product_type.pk})
# When all products have only one variant you can change
# has_variants to false
data = {
"name": product_type.name,
"product_attributes": product_type.product_attributes.values_list(
"pk", flat=True
),
"variant_attributes": product_type.variant_attributes.values_list(
"pk", flat=True
),
"has_variants": False,
"weight": ["3.47"],
}
response = admin_client.post(url, data)
assert response.status_code == 302
assert get_redirect_location(response) == url
product_type.refresh_from_db()
assert not product_type.has_variants
assert product.variants.count() == 1
def test_view_cancel_order_line(admin_client, draft_order):
lines_before = draft_order.lines.all()
lines_before_count = lines_before.count()
line = lines_before.first()
line_quantity = line.quantity
quantity_allocated_before = line.variant.quantity_allocated
url = reverse(
'dashboard:orderline-cancel', kwargs={
'order_pk': draft_order.pk,
'line_pk': line.pk})
response = admin_client.get(url)
assert response.status_code == 200
response = admin_client.post(url, {'csrfmiddlewaretoken': 'hello'})
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
'dashboard:order-details', args=[draft_order.pk])
# check ordered item removal
lines_after = Order.objects.get().lines.all()
assert lines_before_count - 1 == lines_after.count()
# check stock deallocation
line.variant.refresh_from_db()
assert line.variant.quantity_allocated == (
quantity_allocated_before - line_quantity)
url = reverse(
'dashboard:orderline-cancel', kwargs={
'order_pk': draft_order.pk,
'line_pk': OrderLine.objects.get().pk})
response = admin_client.post(
url, {'csrfmiddlewaretoken': 'hello'}, follow=True)
assert Order.objects.get().lines.all().count() == 0
# check success messages after redirect
assert response.context['messages']
def test_add_order_note_view(order, authorized_client, customer_user):
order.user_email = customer_user.email
order.save()
url = reverse("order:details", kwargs={"token": order.token})
customer_note = "bla-bla note"
data = {"customer_note": customer_note}
response = authorized_client.post(url, data)
redirect_url = reverse("order:details", kwargs={"token": order.token})
assert get_redirect_location(response) == redirect_url
order.refresh_from_db()
assert order.customer_note == customer_note
# Ensure an order event was triggered
note_event = order_events.OrderEvent.objects.get() # type: order_events.OrderEvent
assert note_event.type == order_events.OrderEvents.NOTE_ADDED
assert note_event.user == customer_user
assert note_event.order == order
assert note_event.parameters == {"message": customer_note}
# Ensure a customer event was triggered
note_event = account_events.CustomerEvent.objects.get()
assert note_event.type == account_events.CustomerEvents.NOTE_ADDED_TO_ORDER
assert note_event.user == customer_user
assert note_event.order == order
assert note_event.parameters == {"message": customer_note}
def test_view_product_type_edit_to_no_variants_valid(admin_client, product):
product_type = ProductType.objects.create(
name='New product type', has_variants=True)
product.product_type = product_type
product.save()
url = reverse(
'dashboard:product-type-update', kwargs={'pk': product_type.pk})
# When all products have only one variant you can change
# has_variants to false
data = {
'name': product_type.name,
'product_attributes': product_type.product_attributes.values_list(
'pk', flat=True),
'variant_attributes': product_type.variant_attributes.values_list(
'pk', flat=True),
'has_variants': False}
response = admin_client.post(url, data)
assert response.status_code == 302
assert get_redirect_location(response) == url
product_type.refresh_from_db()
assert not product_type.has_variants
assert product.variants.count() == 1
def test_view_add_variant_to_order(admin_client, order_with_lines, admin_user):
order_with_lines.status = OrderStatus.DRAFT
order_with_lines.save()
variant = ProductVariant.objects.get(sku="SKU_A")
line = OrderLine.objects.get(product_sku="SKU_A")
line_quantity_before = line.quantity
assert not OrderEvent.objects.exists()
added_quantity = 2
url = reverse(
"dashboard:add-variant-to-order", kwargs={"order_pk": order_with_lines.pk}
)
data = {"variant": variant.pk, "quantity": added_quantity}
response = admin_client.post(url, data)
line.refresh_from_db()
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
"dashboard:order-details", kwargs={"order_pk": order_with_lines.pk}
)
assert line.quantity == line_quantity_before + added_quantity
removed_items_event = OrderEvent.objects.last()
assert removed_items_event.type == OrderEvents.DRAFT_ADDED_PRODUCTS
assert removed_items_event.user == admin_user
assert removed_items_event.parameters == {
"lines": [{"quantity": line.quantity, "line_pk": line.pk, "item": str(line)}]
}
def test_view_cancel_order_line(admin_client, draft_order, track_inventory, admin_user):
lines_before = draft_order.lines.all()
lines_before_count = lines_before.count()
line = lines_before.first()
line_quantity = line.quantity
quantity_allocated_before = line.variant.quantity_allocated
line.variant.track_inventory = track_inventory
line.variant.save()
assert not OrderEvent.objects.exists()
url = reverse(
"dashboard:orderline-cancel",
kwargs={"order_pk": draft_order.pk, "line_pk": line.pk},
)
response = admin_client.get(url)
assert response.status_code == 200
response = admin_client.post(url, {"csrfmiddlewaretoken": "hello"})
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
"dashboard:order-details", args=[draft_order.pk]
)
# check ordered item removal
lines_after = Order.objects.get().lines.all()
assert lines_before_count - 1 == lines_after.count()
# check stock deallocation
line.variant.refresh_from_db()
if track_inventory:
assert line.variant.quantity_allocated == (
quantity_allocated_before - line_quantity
)
else:
assert line.variant.quantity_allocated == quantity_allocated_before
removed_items_event = OrderEvent.objects.last()
assert removed_items_event.type == OrderEvents.DRAFT_REMOVED_PRODUCTS
assert removed_items_event.user == admin_user
assert removed_items_event.parameters == {
"lines": [
{
"quantity": line.quantity,
"line_pk": None, # the line was deleted
"item": str(line),
}
]
}
url = reverse(
"dashboard:orderline-cancel",
kwargs={"order_pk": draft_order.pk, "line_pk": OrderLine.objects.get().pk},
)
response = admin_client.post(url, {"csrfmiddlewaretoken": "hello"}, follow=True)
assert Order.objects.get().lines.all().count() == 0
# check success messages after redirect
assert response.context["messages"]
def test_view_remove_draft_order(admin_client, draft_order):
url = reverse("dashboard:draft-order-delete", kwargs={"order_pk": draft_order.pk})
response = admin_client.post(url, {})
assert response.status_code == 302
assert get_redirect_location(response) == reverse("dashboard:orders")
assert Order.objects.count() == 0
def test_checkout_flow(request_cart_with_item, client, shipping_method): # pylint: disable=W0613,R0914
"""
Basic test case that confirms if core checkout flow works
"""
# Enter checkout
checkout_index = client.get(reverse('checkout:index'), follow=True)
# Checkout index redirects directly to shipping address step
shipping_address = client.get(checkout_index.request['PATH_INFO'])
# Enter shipping address data
shipping_data = {
'email': '*****@*****.**',
'first_name': 'John',
'last_name': 'Doe',
'street_address_1': 'Aleje Jerozolimskie 2',
'street_address_2': '',
'city': 'Warszawa',
'city_area': '',
'country_area': '',
'postal_code': '00-374',
'country': 'PL'}
shipping_response = client.post(shipping_address.request['PATH_INFO'],
data=shipping_data, follow=True)
# Select shipping method
shipping_method_page = client.get(shipping_response.request['PATH_INFO'])
# Redirect to summary after shipping method selection
shipping_method_data = {'method': shipping_method.pk}
shipping_method_response = client.post(shipping_method_page.request['PATH_INFO'],
data=shipping_method_data, follow=True)
# Summary page asks for Billing address, default is the same as shipping
address_data = {'address': 'shipping_address'}
summary_response = client.post(shipping_method_response.request['PATH_INFO'],
data=address_data, follow=True)
# After summary step, order is created and it waits for payment
order = summary_response.context['order']
# Select payment method
payment_page = client.post(summary_response.request['PATH_INFO'],
data={'method': 'default'}, follow=True)
assert len(payment_page.redirect_chain) == 1
assert payment_page.status_code == 200
# Go to payment details page, enter payment data
payment_page_url = payment_page.redirect_chain[0][0]
payment_data = {
'status': PaymentStatus.PREAUTH,
'fraud_status': FraudStatus.UNKNOWN,
'gateway_response': '3ds-disabled',
'verification_result': 'waiting'}
payment_response = client.post(payment_page_url, data=payment_data)
assert payment_response.status_code == 302
order_password = reverse('order:create-password',
kwargs={'token': order.token})
assert get_redirect_location(payment_response) == order_password
def test_view_product_select_type(admin_client, product_type):
url = reverse('dashboard:product-add-select-type')
data = {'product_type': product_type.pk}
response = admin_client.post(url, data)
assert get_redirect_location(response) == reverse(
'dashboard:product-add', kwargs={'type_pk': product_type.pk})
assert response.status_code == 302
def test_summary_without_address(request_cart_with_item, client): # pylint: disable=W0613
"""
user tries to get summary step without saved shipping method -
if is redirected to shipping method step
"""
response = client.get(reverse('checkout:summary'))
assert response.status_code == 302
assert get_redirect_location(response) == reverse('checkout:shipping-method')
def test_view_connect_order_with_user_different_email(
order, authorized_client):
url = reverse(
'order:connect-order-with-user', kwargs={'token': order.token})
response = authorized_client.post(url)
redirect_location = get_redirect_location(response)
assert redirect_location == reverse('account:details')
order.refresh_from_db()
assert order.user is None
def test_client_login(request_cart_with_item, client, admin_user):
data = {
'username': admin_user.email,
'password': '******'
}
response = client.post(reverse('registration:login'), data=data)
assert response.status_code == 302
assert get_redirect_location(response) == '/'
response = client.get(reverse('checkout:shipping-address'))
assert response.context['checkout'].cart.token == request_cart_with_item.token
def test_view_product_variant_details_redirect_to_product(
admin_client, product):
variant = product.variants.get()
url = reverse(
'dashboard:variant-details',
kwargs={'product_pk': product.pk, 'variant_pk': variant.pk})
response = admin_client.get(url)
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
'dashboard:product-details', kwargs={'pk': product.pk})
def test_view_order_create(admin_client):
url = reverse('dashboard:order-create')
response = admin_client.post(url, {})
assert response.status_code == 302
assert Order.objects.count() == 1
order = Order.objects.first()
redirect_url = reverse(
'dashboard:order-details', kwargs={'order_pk': order.pk})
assert get_redirect_location(response) == redirect_url
assert order.status == OrderStatus.DRAFT
def test_summary_without_shipping_method(request_cart_with_item, client, monkeypatch): # pylint: disable=W0613
"""
user tries to get summary step without saved shipping method -
if is redirected to shipping method step
"""
# address test return true
monkeypatch.setattr('saleor.checkout.core.Checkout.email',
True)
response = client.get(reverse('checkout:summary'))
assert response.status_code == 302
assert get_redirect_location(response) == reverse('checkout:shipping-method')
def test_view_create_from_draft_order_valid(admin_client, draft_order):
order = draft_order
url = reverse("dashboard:create-order-from-draft", kwargs={"order_pk": order.pk})
data = {"csrfmiddlewaretoken": "hello"}
response = admin_client.post(url, data)
assert response.status_code == 302
order.refresh_from_db()
assert order.status == OrderStatus.UNFULFILLED
redirect_url = reverse("dashboard:order-details", kwargs={"order_pk": order.pk})
assert get_redirect_location(response) == redirect_url
def test_shipping_method_without_shipping(request_cart_with_item, client, monkeypatch): # pylint: disable=W0613
"""
user tries to get shipping method step in checkout without shipping -
if is redirected to summary step
"""
monkeypatch.setattr('saleor.checkout.core.Checkout.is_shipping_required',
False)
response = client.get(reverse('checkout:shipping-method'))
assert response.status_code == 302
assert get_redirect_location(response) == reverse('checkout:summary')
def test_view_product_bulk_update_publish(admin_client, product_list):
url = reverse("dashboard:product-bulk-update")
products = [product.pk for product in product_list]
data = {"action": ProductBulkAction.PUBLISH, "products": products}
response = admin_client.post(url, data)
assert response.status_code == 302
assert get_redirect_location(response) == reverse("dashboard:product-list")
for p in product_list:
p.refresh_from_db()
assert p.is_published
def test_add_order_note_view(order, authorized_client, customer_user):
order.user_email = customer_user.email
order.save()
url = reverse('order:details', kwargs={'token': order.token})
customer_note = 'bla-bla note'
data = {'customer_note': customer_note}
response = authorized_client.post(url, data)
redirect_url = reverse('order:details', kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
order.refresh_from_db()
assert order.customer_note == customer_note
def test_create_user_after_order(order, client):
order.user_email = '*****@*****.**'
order.save()
url = reverse('order:checkout-success', kwargs={'token': order.token})
data = {'password': '******'}
response = client.post(url, data)
redirect_url = reverse('order:details', kwargs={'token': order.token})
assert get_redirect_location(response) == redirect_url
user = User.objects.filter(email='*****@*****.**').first()
assert user is not None
assert user.orders.filter(token=order.token).exists()
def test_view_connect_order_with_user_authorized_user(
order, authorized_client, customer_user):
order.user_email = customer_user.email
order.save()
url = reverse(
'order:connect-order-with-user', kwargs={'token': order.token})
response = authorized_client.post(url)
redirect_location = get_redirect_location(response)
assert redirect_location == reverse('order:details', args=[order.token])
order.refresh_from_db()
assert order.user == customer_user
def test_view_product_type_create_variantless(
admin_client, color_attribute, size_attribute):
url = reverse('dashboard:product-type-add')
data = {
'name': 'Testing Type',
'product_attributes': [color_attribute.pk],
'variant_attributes': [],
'has_variants': False}
response = admin_client.post(url, data)
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
'dashboard:product-type-list')
assert ProductType.objects.count() == 1
def test_checkout_flow_authenticated_user(authorized_client, billing_address, # pylint: disable=R0914
request_cart_with_item, customer_user,
shipping_method):
"""
Checkout with authenticated user and previously saved address
"""
# Prepare some data
customer_user.addresses.add(billing_address)
request_cart_with_item.user = customer_user
request_cart_with_item.save()
# Enter checkout
# Checkout index redirects directly to shipping address step
shipping_address = authorized_client.get(reverse('checkout:index'), follow=True)
# Enter shipping address data
shipping_data = {'address': billing_address.pk}
shipping_method_page = authorized_client.post(shipping_address.request['PATH_INFO'],
data=shipping_data, follow=True)
# Select shipping method
shipping_method_data = {'method': shipping_method.pk}
shipping_method_response = authorized_client.post(shipping_method_page.request['PATH_INFO'],
data=shipping_method_data, follow=True)
# Summary page asks for Billing address, default is the same as shipping
payment_method_data = {'address': 'shipping_address'}
payment_method_page = authorized_client.post(shipping_method_response.request['PATH_INFO'],
data=payment_method_data, follow=True)
# After summary step, order is created and it waits for payment
order = payment_method_page.context['order']
# Select payment method
payment_page = authorized_client.post(payment_method_page.request['PATH_INFO'],
data={'method': 'default'}, follow=True)
# Go to payment details page, enter payment data
payment_data = {
'status': PaymentStatus.PREAUTH,
'fraud_status': FraudStatus.UNKNOWN,
'gateway_response': '3ds-disabled',
'verification_result': 'waiting'}
payment_response = authorized_client.post(payment_page.request['PATH_INFO'],
data=payment_data)
assert payment_response.status_code == 302
order_password = reverse('order:create-password',
kwargs={'token': order.token})
assert get_redirect_location(payment_response) == order_password
def test_view_order_customer_edit_to_email(admin_client, draft_order):
url = reverse("dashboard:order-customer-edit", kwargs={"order_pk": draft_order.pk})
data = {"user_email": "*****@*****.**", "user": "", "update_addresses": False}
response = admin_client.post(url, data)
assert response.status_code == 302
draft_order.refresh_from_db()
assert draft_order.user_email == "*****@*****.**"
assert not draft_order.user
redirect_url = reverse(
"dashboard:order-details", kwargs={"order_pk": draft_order.pk}
)
assert get_redirect_location(response) == redirect_url
def test_view_cancel_fulfillment(admin_client, fulfilled_order):
fulfillment = fulfilled_order.fulfillments.first()
url = reverse(
'dashboard:fulfillment-cancel',
kwargs={
'order_pk': fulfilled_order.pk,
'fulfillment_pk': fulfillment.pk})
response = admin_client.post(url, {'csrfmiddlewaretoken': 'hello'})
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
'dashboard:order-details', kwargs={'order_pk': fulfilled_order.pk})
fulfillment.refresh_from_db()
assert fulfillment.status == FulfillmentStatus.CANCELED
def test_create_user_after_order(order, client):
order.user_email = '*****@*****.**'
order.save()
assert not User.objects.filter(email='*****@*****.**').exists()
data = {'password': '******'}
url = reverse('order:create-password', kwargs={'token': order.token})
response = client.post(url, data=data)
redirect_location = get_redirect_location(response)
detail_url = reverse('order:details', kwargs={'token': order.token})
assert redirect_location == detail_url
user = User.objects.filter(email='*****@*****.**')
assert user.exists()
user = user.first()
assert user.orders.filter(token=order.token).exists()
def test_view_product_edit(admin_client, product):
url = reverse('dashboard:product-update', kwargs={'pk': product.pk})
data = {
'name': 'Product second name', 'description': 'Product description.',
'price': 10, 'category': product.category.pk, 'variant-sku': '123',
'variant-quantity': 10}
response = admin_client.post(url, data)
assert response.status_code == 302
product.refresh_from_db()
assert get_redirect_location(response) == reverse(
'dashboard:product-details', kwargs={'pk': product.pk})
assert product.name == 'Product second name'
def test_view_order_customer_edit_to_guest_customer(admin_client, draft_order):
url = reverse(
'dashboard:order-customer-edit', kwargs={'order_pk': draft_order.pk})
data = {'user_email': '', 'user': '', 'update_addresses': False}
response = admin_client.post(url, data)
assert response.status_code == 302
draft_order.refresh_from_db()
assert not draft_order.user_email
assert not draft_order.user
redirect_url = reverse(
'dashboard:order-details', kwargs={'order_pk': draft_order.pk})
assert get_redirect_location(response) == redirect_url
def test_view_cancel_order_line(admin_client, draft_order, track_inventory,
admin_user):
lines_before = draft_order.lines.all()
lines_before_count = lines_before.count()
line = lines_before.first()
line_quantity = line.quantity
quantity_allocated_before = line.variant.quantity_allocated
line.variant.track_inventory = track_inventory
line.variant.save()
assert not OrderEvent.objects.exists()
url = reverse(
"dashboard:orderline-cancel",
kwargs={
"order_pk": draft_order.pk,
"line_pk": line.pk
},
)
response = admin_client.get(url)
assert response.status_code == 200
response = admin_client.post(url, {"csrfmiddlewaretoken": "hello"})
assert response.status_code == 302
assert get_redirect_location(response) == reverse(
"dashboard:order-details", args=[draft_order.pk])
# check ordered item removal
lines_after = Order.objects.get().lines.all()
assert lines_before_count - 1 == lines_after.count()
# check stock deallocation
line.variant.refresh_from_db()
if track_inventory:
assert line.variant.quantity_allocated == (quantity_allocated_before -
line_quantity)
else:
assert line.variant.quantity_allocated == quantity_allocated_before
removed_items_event = OrderEvent.objects.last()
assert removed_items_event.type == OrderEvents.DRAFT_REMOVED_PRODUCTS
assert removed_items_event.user == admin_user
assert removed_items_event.parameters == {
"lines": [{
"quantity": line.quantity,
"line_pk": None, # the line was deleted
"item": str(line),
}]
}
url = reverse(
"dashboard:orderline-cancel",
kwargs={
"order_pk": draft_order.pk,
"line_pk": OrderLine.objects.get().pk
},
)
response = admin_client.post(url, {"csrfmiddlewaretoken": "hello"},
follow=True)
assert Order.objects.get().lines.all().count() == 0
# check success messages after redirect
assert response.context["messages"]
def test_checkout_flow_authenticated_user(
authorized_client,
billing_address, # pylint: disable=R0914
request_cart_with_item,
customer_user,
shipping_method):
"""
Checkout with authenticated user and previously saved address
"""
# Prepare some data
customer_user.addresses.add(billing_address)
request_cart_with_item.user = customer_user
request_cart_with_item.save()
# Enter checkout
# Checkout index redirects directly to shipping address step
shipping_address = authorized_client.get(reverse('checkout:index'),
follow=True)
# Enter shipping address data
shipping_data = {'address': billing_address.pk}
shipping_method_page = authorized_client.post(
shipping_address.request['PATH_INFO'], data=shipping_data, follow=True)
# Select shipping method
shipping_method_data = {'method': shipping_method.pk}
shipping_method_response = authorized_client.post(
shipping_method_page.request['PATH_INFO'],
data=shipping_method_data,
follow=True)
# Summary page asks for Billing address, default is the same as shipping
payment_method_data = {'address': 'shipping_address'}
payment_method_page = authorized_client.post(
shipping_method_response.request['PATH_INFO'],
data=payment_method_data,
follow=True)
# After summary step, order is created and it waits for payment
order = payment_method_page.context['order']
# Select payment method
payment_page = authorized_client.post(
payment_method_page.request['PATH_INFO'],
data={'method': 'default'},
follow=True)
# Go to payment details page, enter payment data
payment_data = {
'status': PaymentStatus.PREAUTH,
'fraud_status': FraudStatus.UNKNOWN,
'gateway_response': '3ds-disabled',
'verification_result': 'waiting'
}
payment_response = authorized_client.post(
payment_page.request['PATH_INFO'], data=payment_data)
assert payment_response.status_code == 302
order_password = reverse('order:create-password',
kwargs={'token': order.token})
assert get_redirect_location(payment_response) == order_password
def test_checkout_flow(request_cart_with_item, client, shipping_method): # pylint: disable=W0613,R0914
"""
Basic test case that confirms if core checkout flow works
"""
# Enter checkout
checkout_index = client.get(reverse('checkout:index'), follow=True)
# Checkout index redirects directly to shipping address step
shipping_address = client.get(checkout_index.request['PATH_INFO'])
# Enter shipping address data
shipping_data = {
'email': '*****@*****.**',
'first_name': 'John',
'last_name': 'Doe',
'street_address_1': 'Aleje Jerozolimskie 2',
'street_address_2': '',
'city': 'Warszawa',
'city_area': '',
'country_area': '',
'postal_code': '00-374',
'country': 'PL'
}
shipping_response = client.post(shipping_address.request['PATH_INFO'],
data=shipping_data,
follow=True)
# Select shipping method
shipping_method_page = client.get(shipping_response.request['PATH_INFO'])
# Redirect to summary after shipping method selection
shipping_method_data = {'method': shipping_method.pk}
shipping_method_response = client.post(
shipping_method_page.request['PATH_INFO'],
data=shipping_method_data,
follow=True)
# Summary page asks for Billing address, default is the same as shipping
address_data = {'address': 'shipping_address'}
summary_response = client.post(
shipping_method_response.request['PATH_INFO'],
data=address_data,
follow=True)
# After summary step, order is created and it waits for payment
order = summary_response.context['order']
# Select payment method
payment_page = client.post(summary_response.request['PATH_INFO'],
data={'method': 'default'},
follow=True)
assert len(payment_page.redirect_chain) == 1
assert payment_page.status_code == 200
# Go to payment details page, enter payment data
payment_page_url = payment_page.redirect_chain[0][0]
payment_data = {
'status': 'preauth',
'fraud_status': 'unknown',
'gateway_response': '3ds-disabled',
'verification_result': 'waiting'
}
payment_response = client.post(payment_page_url, data=payment_data)
assert payment_response.status_code == 302
order_details = reverse('order:details', kwargs={'token': order.token})
assert get_redirect_location(payment_response) == order_details
