def test_get_pagination_variables():
populate_if_required() # Makes sure there is at least 30 products in db
products = Product.objects.all()[:19]
assert len(products) == 19
vars = {"products": products}
context = get_jinja_context(**vars)
variables = general.get_pagination_variables(context, context["products"], limit=4)
assert variables["page"].number == 1
assert len(variables["objects"]) == 4
context = get_jinja_context(path="/?page=5", **vars)
variables = general.get_pagination_variables(context, context["products"], limit=4)
assert variables["page"].number == 5
assert len(variables["objects"]) == 3
variables = general.get_pagination_variables(context, context["products"], limit=20)
assert not variables["is_paginated"]
assert variables["page"].number == 1
context = get_jinja_context(path="/?page=42", **vars)
variables = general.get_pagination_variables(context, context["products"], limit=4)
assert variables["page"].number == 5
assert len(variables["objects"]) == 3
vars = {"products": []}
context = get_jinja_context(path="/", **vars)
variables = general.get_pagination_variables(context, context["products"], limit=4)
assert not variables["is_paginated"]
def test_basic_order_flow(with_company):
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
c = SmartClient()
product_ids = _populate_client_basket(c)
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=with_company)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
def test_get_installments_12x_with_simples_intereset():
"""
Max 12 installs with PRICE intereset
interest_rate = 2.30%
min_installment_amount = 30.00
"""
patch_cielo_request()
shop = get_default_shop()
create_default_order_statuses()
populate_if_required()
set_current_theme('shuup.themes.classic_gray')
c = SmartClient()
_configure_basket(c)
cielo_config = CieloConfig.objects.create(shop=shop,
max_installments=12,
installments_without_interest=2,
interest_type=InterestType.Price,
interest_rate=Decimal(2.3),
min_installment_amount=Decimal(30))
order_total = (PRODUCT_QTNTY * PRODUCT_PRICE)
installment_choices = InstallmentContext(order_total, cielo_config).get_intallments_choices()
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Visa})
json_content = json.loads(response.content.decode("utf-8"))
assert len(json_content['installments']) == len(installment_choices)
for installment in range(len(installment_choices)):
total = format_money(shop.create_price(installment_choices[installment][2]))
installment_amount = format_money(shop.create_price(installment_choices[installment][1]))
assert json_content['installments'][installment]['number'] == installment+1
assert installment_amount in json_content['installments'][installment]['name']
assert total in json_content['installments'][installment]['name']
def test_get_installments_cc_does_not_allow_installments():
"""
Max 9 installs with SIMPLE intereset
interest_rate = 4.00%
Credit card does not allow installments
"""
patch_cielo_request()
shop = get_default_shop()
create_default_order_statuses()
populate_if_required()
set_current_theme('shuup.themes.classic_gray')
c = SmartClient()
_configure_basket(c)
CieloConfig.objects.create(shop=shop,
max_installments=9,
installments_without_interest=3,
interest_type=InterestType.Simple,
interest_rate=Decimal(4.0))
order_total = (PRODUCT_QTNTY * PRODUCT_PRICE)
total_price_str = "{0}".format(format_money(shop.create_price(order_total)))
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Discover})
json_content = json.loads(response.content.decode("utf-8"))
assert len(json_content['installments']) == 1
assert json_content['installments'][0]['number'] == 1
assert total_price_str in json_content['installments'][0]['name']
def test_get_installments_3x_no_intereset():
"""
Max 3 installs with no intereset
"""
patch_cielo_request()
shop = get_default_shop()
create_default_order_statuses()
populate_if_required()
set_current_theme('shuup.themes.classic_gray')
c = SmartClient()
_configure_basket(c)
CieloConfig.objects.create(shop=shop,
max_installments=3,
installments_without_interest=3)
order_total = PRODUCT_QTNTY * PRODUCT_PRICE
total_price_str = "{0}".format(format_money(shop.create_price(order_total)))
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Visa})
json_content = json.loads(response.content.decode("utf-8"))
assert len(json_content['installments']) == 3
assert json_content['installments'][0]['number'] == 1
assert total_price_str in json_content['installments'][0]['name']
total_2x_no_interest = format_money(shop.create_price(order_total / Decimal(2)))
assert json_content['installments'][1]['number'] == 2
assert total_price_str in json_content['installments'][1]['name']
assert total_2x_no_interest in json_content['installments'][1]['name']
total_3x_no_interest = format_money(shop.create_price(order_total / Decimal(3)))
assert json_content['installments'][2]['number'] == 3
assert total_price_str in json_content['installments'][2]['name']
assert total_3x_no_interest in json_content['installments'][2]['name']
def test_basic_order_flow_registered(regular_user):
cache.clear()
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
get_test_script("test script", "order_received")
# paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
template_data = STEP_DATA[0]["actions"][0]["template_data"]
LANG_CODE = {
"en": "US",
"fi": "FI"
}
for lang in ["en", "fi"]:
n_outbox_pre = len(mail.outbox)
contact = get_person_contact(regular_user)
contact.language = lang
contact.save()
c = SmartClient()
c.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD)
product_ids = _populate_client_basket(c)
addresses_soup = c.soup(addresses_path)
address = get_address(country=LANG_CODE[lang])
inputs = fill_address_inputs(addresses_soup, address)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
assert (len(mail.outbox) == n_outbox_pre + 1), "Sending email failed"
latest_mail = mail.outbox[-1]
# mail is always sent in fallback language since user is not registered
assert latest_mail.subject == template_data[lang]["subject"], "Subject doesn't match"
assert latest_mail.body == template_data[lang]["body"], "Body doesn't match"
def initialize():
get_cielo_config()
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
default_product = get_default_product()
sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop())
sp.default_price = get_default_shop().create_price(PRODUCT_PRICE)
sp.save()
def _get_configured_basket_client():
"""
Initialized and configure client
adding product and setting address,
ready to make transactions
"""
get_default_shop()
create_default_order_statuses()
populate_if_required()
set_current_theme('shuup.themes.classic_gray')
c = SmartClient()
_configure_basket(c)
return c
def test_checkout_empty_basket(rf):
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
c = SmartClient()
product_ids = _populate_client_basket(c)
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup)
for product_id in product_ids:
Product.objects.get(pk=product_id).soft_delete()
response, soup = c.response_and_soup(addresses_path, data=inputs, method="post")
assert response.status_code == 200 # Should redirect forth
assert b"Your shopping cart is empty." in soup.renderContents()
def test_basic_order_flow(with_company, with_signal):
cache.clear()
create_default_order_statuses()
n_orders_pre = Order.objects.count()
populate_if_required()
c = SmartClient()
product_ids = _populate_client_basket(c)
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=with_company)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302 # Should redirect forth
# Make sure the address is initialized from storage
# Go back to addresses right before back to methods
c.soup(addresses_path)
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = c.soup(methods_path)
assert c.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
if with_signal:
checkout_complete.connect(checkout_complete_signal, dispatch_uid="checkout_complete_signal")
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = c.soup(confirm_path)
Product.objects.get(pk=product_ids[0]).soft_delete()
assert c.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 200 # user needs to reconfirm
data = extract_form_fields(confirm_soup)
data['product_ids'] = ','.join(product_ids[1:])
assert c.post(confirm_path, data=data).status_code == 302 # Should redirect forth
n_orders_post = Order.objects.count()
assert n_orders_post > n_orders_pre, "order was created"
order = Order.objects.first()
expected_ip = "127.0.0.2" if with_signal else "127.0.0.1"
assert order.ip_address == expected_ip
if with_signal:
checkout_complete.disconnect(dispatch_uid="checkout_complete_signal")
def test_get_installments_options_rest():
patch_cielo_request()
shop = get_default_shop()
c = SmartClient()
# method not allowed
response = c.post(INSTALLMENTS_PATH)
assert response.status_code == 405
# missing parameters
response = c.get(INSTALLMENTS_PATH)
assert response.status_code == 400
# no CieloConfig for shop
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Visa})
assert response.status_code == 400
CieloConfig.objects.create(shop=shop)
# basket not valid (no products and not payment/shipping methods)
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Visa})
assert response.status_code == 400
create_default_order_statuses()
populate_if_required()
set_current_theme('shuup.themes.classic_gray')
# configures the user basket
_configure_basket(c)
# only 1 installment, because no configurations were set on CieloConfig
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Visa})
assert response.status_code == 200
# should be the order total
order_total = PRODUCT_QTNTY * PRODUCT_PRICE
total_price_str = "{0}".format(format_money(shop.create_price(order_total)))
json_content = json.loads(response.content.decode("utf-8"))
assert len(json_content['installments']) == 1
assert json_content['installments'][0]['number'] == 1
assert total_price_str in json_content['installments'][0]['name']
def test_get_pagination_variables():
from shuup.front.template_helpers import general
populate_if_required() # Makes sure there is at least 30 products in db
products = Product.objects.all()[:19]
assert len(products) == 19
vars = {"products": products}
context = get_jinja_context(**vars)
variables = general.get_pagination_variables(context, context["products"], limit=2)
assert variables["page"].number == 1
assert len(variables["objects"]) == 2
assert variables["page_range"][0] == 1
assert variables["page_range"][-1] == 5
context = get_jinja_context(path="/?page=5", **vars)
variables = general.get_pagination_variables(context, context["products"], limit=2)
assert variables["page"].number == 5
assert len(variables["objects"]) == 2
assert variables["page_range"][0] == 3
assert variables["page_range"][-1] == 7
variables = general.get_pagination_variables(context, context["products"], limit=20)
assert not variables["is_paginated"]
assert variables["page"].number == 1
assert variables["page_range"][0] == variables["page_range"][-1] == 1
context = get_jinja_context(path="/?page=42", **vars)
variables = general.get_pagination_variables(context, context["products"], limit=4)
assert variables["page"].number == 5
assert len(variables["objects"]) == 3
assert variables["page_range"][0] == 1
assert variables["page_range"][-1] == 5
vars = {"products": []}
context = get_jinja_context(path="/", **vars)
variables = general.get_pagination_variables(context, context["products"], limit=4)
assert not variables["is_paginated"]
assert variables["page_range"][0] == variables["page_range"][-1] == 1
def test_get_installments_9x_with_simples_intereset():
"""
Max 9 installs with SIMPLE intereset
interest_rate = 4.00%
"""
patch_cielo_request()
shop = get_default_shop()
create_default_order_statuses()
populate_if_required()
set_current_theme('shuup.themes.classic_gray')
c = SmartClient()
_configure_basket(c)
cielo_config = CieloConfig.objects.create(shop=shop,
max_installments=9,
installments_without_interest=3,
interest_type=InterestType.Simple,
interest_rate=Decimal(4.0))
SHIP_AMOUNT = Decimal(19.0)
shipping_method = get_default_shipping_method()
shipping_method.behavior_components.add(
FixedCostBehaviorComponent.objects.create(price_value=SHIP_AMOUNT)
)
order_total = (PRODUCT_QTNTY * PRODUCT_PRICE) + SHIP_AMOUNT
installment_choices = InstallmentContext(order_total, cielo_config).get_intallments_choices()
response = c.get(INSTALLMENTS_PATH, {"cc_brand": CieloCardBrand.Visa})
json_content = json.loads(response.content.decode("utf-8"))
assert len(json_content['installments']) == len(installment_choices)
for installment in range(len(installment_choices)):
total = format_money(shop.create_price(installment_choices[installment][2]))
installment_amount = format_money(shop.create_price(installment_choices[installment][1]))
assert json_content['installments'][installment]['number'] == installment+1
assert installment_amount in json_content['installments'][installment]['name']
assert total in json_content['installments'][installment]['name']
def test_picotable_correctly_sorts_translated_fields(rf, admin_user, regular_user):
"""
Make sure that translated fields, such as product names, are correctly sorted
"""
populate_if_required()
columns = [
Column("id", "Id", filter_config=Filter(), display=instance_id),
Column(
"name", "Name", sort_field="translations__name",
filter_config=TextFilter(filter_field="translations__name")),
]
pico = get_pico(rf, model=Product, columns=columns)
# Verify ascending sort
sorted_products = pico.get_data({"perPage": 100, "page": 1, "sort": "+name"})
sorted_names = [p["name"] for p in sorted_products["items"]]
assert sorted_names == sorted(sorted_names)
# Verify descending sort
sorted_products = pico.get_data({"perPage": 100, "page": 1, "sort": "-name"})
sorted_names = [p["name"] for p in sorted_products["items"]]
assert sorted_names == sorted(sorted_names, reverse=True)
def test_get_random_products():
populate_if_required()
context = get_jinja_context()
assert len(list(general.get_random_products(context, n_products=4))) == 4
def test_get_root_categories():
populate_if_required()
context = get_jinja_context()
for root in general.get_root_categories(context=context):
assert not root.parent_id
def test_order_flow_with_phases(get_shipping_method, shipping_data, get_payment_method, payment_data):
cache.clear()
create_default_order_statuses()
populate_if_required()
c = SmartClient()
_populate_client_basket(c)
# Create methods
shipping_method = get_shipping_method()
payment_method = get_payment_method()
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
shipping_path = reverse("shuup:checkout", kwargs={"phase": "shipping"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth to methods"
# Phase: Methods
response = c.get(methods_path)
assert response.status_code == 200
response = c.post(
methods_path,
data={
"shipping_method": shipping_method.pk,
"payment_method": payment_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
if isinstance(shipping_method.carrier, CarrierWithCheckoutPhase):
# Phase: Shipping
response = c.get(shipping_path)
assert response.status_code == 200
response = c.post(shipping_path, data=shipping_data)
assert response.status_code == 302, "Payments phase should redirect forth"
if isinstance(payment_method.payment_processor, PaymentWithCheckoutPhase):
# Phase: payment
response = c.get(payment_path)
assert response.status_code == 200
response = c.post(payment_path, data=payment_data)
assert response.status_code == 302, "Payments phase should redirect forth"
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
data = extract_form_fields(confirm_soup)
data["accept_terms"] = True
response = c.post(confirm_path, data)
assert response.status_code == 302, "Confirm should redirect forth"
order = Order.objects.first()
if isinstance(shipping_method.carrier, CarrierWithCheckoutPhase):
assert order.shipping_data.get("input_value") == "20540"
if isinstance(payment_method.payment_processor, PaymentWithCheckoutPhase):
assert order.payment_data.get("input_value")
assert order.payment_status == PaymentStatus.NOT_PAID
# Resolve order specific paths (payment and complete)
process_payment_path = reverse(
"shuup:order_process_payment",
kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse(
"shuup:order_process_payment_return",
kwargs={"pk": order.pk, "key": order.key})
order_complete_path = reverse(
"shuup:order_complete",
kwargs={"pk": order.pk, "key": order.key})
# Check confirm redirection to payment page
assert response.url.endswith(process_payment_path), (
"Confirm should have redirected to payment page")
# Visit payment page
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
# Check payment return
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
# Check payment status has changed to DEFERRED
order = Order.objects.get(pk=order.pk) # reload
assert order.payment_status == PaymentStatus.DEFERRED
def test_get_all_manufacturers():
populate_if_required()
context = get_jinja_context()
# TODO: This is not a good test
assert len(general.get_all_manufacturers(context)) == 0
def test_get_root_categories():
populate_if_required()
context = get_jinja_context()
from shuup.front.template_helpers import general
for root in general.get_root_categories(context=context):
assert not root.parent_id
def test_checkout(admin_user):
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
create_test_data()
default_product = get_default_product()
sp = ShopProduct.objects.get(product=default_product,
shop=get_default_shop())
sp.default_price = get_default_shop().create_price(Decimal(10.0))
sp.save()
service = get_custom_carrier_service()
component = SpecificShippingTableBehaviorComponent.objects.create(
table=ShippingTable.objects.get(identifier='table-1'))
service.behavior_components.add(component)
c = SmartClient()
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path,
data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
shipping_method = service
payment_method = get_payment_method(name="neat", price=4)
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
inputs['shipping-postal_code'] = "89060201"
inputs['shipping-country'] = "BR"
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == 0
response = c.post(methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
})
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 200
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
assert Order.objects.count() == 1
order = Order.objects.filter(payment_method=payment_method).first()
assert order.payment_status == PaymentStatus.NOT_PAID
def test_get_all_manufacturers():
from shuup.front.template_helpers import general
populate_if_required()
context = get_jinja_context()
# TODO: This is not a good test
assert len(general.get_all_manufacturers(context)) == 0
def test_get_root_categories():
populate_if_required()
context = get_jinja_context()
for root in general.get_root_categories(context=context):
assert not root.parent_id
def test_get_all_manufacturers():
populate_if_required()
context = get_jinja_context()
# TODO: This is not a good test
assert len(general.get_all_manufacturers(context)) == 0
def test_checkout(admin_user):
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
create_test_data()
default_product = get_default_product()
sp = ShopProduct.objects.get(product=default_product, shop=get_default_shop())
sp.default_price = get_default_shop().create_price(Decimal(10.0))
sp.save()
service = get_custom_carrier_service()
component = SpecificShippingTableBehaviorComponent.objects.create(
table=ShippingTable.objects.get(identifier='table-1')
)
service.behavior_components.add(component)
c = SmartClient()
basket_path = reverse("shuup:basket")
add_to_basket_resp = c.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
shipping_method = service
payment_method = get_payment_method(name="neat", price=4)
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
inputs['shipping-postal_code'] = "89060201"
inputs['shipping-country'] = "BR"
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth"
assert response.url.endswith(methods_path)
# Phase: Methods
assert Order.objects.filter(payment_method=payment_method).count() == 0
response = c.post(
methods_path,
data={
"payment_method": payment_method.pk,
"shipping_method": shipping_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
assert response.url.endswith(confirm_path)
response = c.get(confirm_path)
assert response.status_code == 200
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
assert Order.objects.count() == 1
order = Order.objects.filter(payment_method=payment_method).first()
assert order.payment_status == PaymentStatus.NOT_PAID
def test_checkout_with_success():
get_default_shop()
set_current_theme('shuup.themes.classic_gray')
create_default_order_statuses()
populate_if_required()
client = SmartClient()
# first step - register user
person_data = {
"email": "*****@*****.**",
"password1": "password",
"password2": "password",
"person_type": PersonType.FISICA.value,
"PF-name": "NOME DA PESSOA",
"PF-cpf": "012.345.678-90",
"PF-rg": "312321",
"PF-birth_date": "03/28/1954",
"PF-gender": Gender.MALE.value
}
result = client.post(reverse("shuup:registration_register"), data=person_data)
assert not result is None
user = get_user_model().objects.get(email=person_data['email'])
assert user.is_active
# second step -add something into the basket
default_product = get_default_product()
basket_path = reverse("shuup:basket")
add_to_basket_resp = client.post(basket_path, data={
"command": "add",
"product_id": default_product.pk,
"quantity": 1,
"supplier": get_default_supplier().pk
})
assert add_to_basket_resp.status_code < 400
# third step - go to checkout and set the addresses
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
addresses_data = {
'billing-name': 'maria da silva',
'billing-street': 'rua billing',
'billing-street2': 'apto',
'billing-street3': 'bairro outrem',
'billing-postal_code': '89090-200',
'billing-city': 'plumenau',
'billing-region': 'PR',
'billing-country': 'BR',
'billing-phone': '41 2332-0213',
'billing_extra-numero': '563',
'billing_extra-cel': '13 98431-4345',
'billing_extra-ponto_ref': 'longe de tudo',
'shipping-name': 'joao da silva',
'shipping-street': 'rua shipping',
'shipping-street2': 'complemento',
'shipping-street3': 'bairro',
'shipping-postal_code': '89050120',
'shipping-city': 'indaial',
'shipping-region': 'SC',
'shipping-country': 'BR',
'shipping-phone': '39 9999-2332',
'shipping_extra-numero': '323',
'shipping_extra-cel': '21 4444-3333',
'shipping_extra-ponto_ref': 'proximo posto',
}
response = client.post(addresses_path, data=addresses_data)
print (response.content)
assert response.status_code == 302 # Should redirect forth
# Set the payment and shipping methods
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
methods_soup = client.soup(methods_path)
assert client.post(methods_path, data=extract_form_fields(methods_soup)).status_code == 302 # Should redirect forth
# Confirm the order
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
confirm_soup = client.soup(confirm_path)
assert client.post(confirm_path, data=extract_form_fields(confirm_soup)).status_code == 302 # Should redirect forth
def test_get_random_products():
populate_if_required()
context = get_jinja_context()
assert len(list(general.get_random_products(context, n_products=4))) == 4
def test_order_flow_with_phases(get_shipping_method, shipping_data, get_payment_method, payment_data):
create_default_order_statuses()
populate_if_required()
c = SmartClient()
_populate_client_basket(c)
# Create methods
shipping_method = get_shipping_method()
payment_method = get_payment_method()
# Resolve paths
addresses_path = reverse("shuup:checkout", kwargs={"phase": "addresses"})
methods_path = reverse("shuup:checkout", kwargs={"phase": "methods"})
shipping_path = reverse("shuup:checkout", kwargs={"phase": "shipping"})
payment_path = reverse("shuup:checkout", kwargs={"phase": "payment"})
confirm_path = reverse("shuup:checkout", kwargs={"phase": "confirm"})
# Phase: Addresses
addresses_soup = c.soup(addresses_path)
inputs = fill_address_inputs(addresses_soup, with_company=False)
response = c.post(addresses_path, data=inputs)
assert response.status_code == 302, "Address phase should redirect forth to methods"
# Phase: Methods
response = c.get(methods_path)
assert response.status_code == 200
response = c.post(
methods_path,
data={
"shipping_method": shipping_method.pk,
"payment_method": payment_method.pk
}
)
assert response.status_code == 302, "Methods phase should redirect forth"
if isinstance(shipping_method.carrier, CarrierWithCheckoutPhase):
# Phase: Shipping
response = c.get(shipping_path)
assert response.status_code == 200
response = c.post(shipping_path, data=shipping_data)
assert response.status_code == 302, "Payments phase should redirect forth"
if isinstance(payment_method.payment_processor, PaymentWithCheckoutPhase):
# Phase: payment
response = c.get(payment_path)
assert response.status_code == 200
response = c.post(payment_path, data=payment_data)
assert response.status_code == 302, "Payments phase should redirect forth"
# Phase: Confirm
assert Order.objects.count() == 0
confirm_soup = c.soup(confirm_path)
response = c.post(confirm_path, data=extract_form_fields(confirm_soup))
assert response.status_code == 302, "Confirm should redirect forth"
order = Order.objects.first()
if isinstance(shipping_method.carrier, CarrierWithCheckoutPhase):
assert order.shipping_data.get("input_value") == "20540"
if isinstance(payment_method.payment_processor, PaymentWithCheckoutPhase):
assert order.payment_data.get("input_value")
assert order.payment_status == PaymentStatus.NOT_PAID
# Resolve order specific paths (payment and complete)
process_payment_path = reverse(
"shuup:order_process_payment",
kwargs={"pk": order.pk, "key": order.key})
process_payment_return_path = reverse(
"shuup:order_process_payment_return",
kwargs={"pk": order.pk, "key": order.key})
order_complete_path = reverse(
"shuup:order_complete",
kwargs={"pk": order.pk, "key": order.key})
# Check confirm redirection to payment page
assert response.url.endswith(process_payment_path), (
"Confirm should have redirected to payment page")
# Visit payment page
response = c.get(process_payment_path)
assert response.status_code == 302, "Payment page should redirect forth"
assert response.url.endswith(process_payment_return_path)
# Check payment return
response = c.get(process_payment_return_path)
assert response.status_code == 302, "Payment return should redirect forth"
assert response.url.endswith(order_complete_path)
# Check payment status has changed to DEFERRED
order = Order.objects.get(pk=order.pk) # reload
assert order.payment_status == PaymentStatus.DEFERRED
def test_simple_packager1(rf):
populate_if_required()
MAX_WIDTH = 1050
MAX_LENGTH = 1050
MAX_HEIGHT = 1050
MAX_EDGES_SUM = 2000
MAX_WEIGHT = 30000
constraint1 = SimplePackageDimensionConstraint(MAX_WIDTH, MAX_LENGTH,
MAX_HEIGHT, MAX_EDGES_SUM)
constraint2 = WeightPackageConstraint(MAX_WEIGHT)
packager = SimplePackager()
assert packager._constraints == set()
packager.add_constraint(constraint1)
packager.add_constraint(constraint2)
assert constraint1 in packager._constraints
assert constraint2 in packager._constraints
product1 = create_product(sku='p1',
width=250,
depth=200,
height=50,
gross_weight=2340,
shop=get_default_shop(),
supplier=get_default_supplier())
product2 = create_product(sku='p2',
width=500,
depth=150,
height=90,
gross_weight=690,
shop=get_default_shop(),
supplier=get_default_supplier())
assert packager._product_has_valid_attrs(product1) is True
assert packager._product_has_valid_attrs(product2) is True
# cria produtos invalidos, sem propriedades necessárias
# no gross_weight
product_invalid_1 = create_product(sku='pi1',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_1.gross_weight = 0
assert packager._product_has_valid_attrs(product_invalid_1) is False
# no height
product_invalid_2 = create_product(sku='pi2',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_2.height = 0
assert packager._product_has_valid_attrs(product_invalid_2) is False
# no depth
product_invalid_3 = create_product(sku='pi3',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_3.depth = 0
assert packager._product_has_valid_attrs(product_invalid_3) is False
# no width
product_invalid_4 = create_product(sku='pi4',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_4.width = 0
assert packager._product_has_valid_attrs(product_invalid_4) is False
# cria um basket vazio
request = rf.get("/")
request.session = {}
request.shop = get_default_shop()
apply_request_middleware(request)
basket = get_basket(request)
# adiciona um item no carrinho
basket.add_product(supplier=get_default_supplier(),
shop=get_default_shop(),
product=product1,
quantity=2)
basket.add_product(supplier=get_default_supplier(),
shop=get_default_shop(),
product=product2,
quantity=3)
# cria o pedido a partir do carrinho
order_creator = get_basket_order_creator()
basket.status = OrderStatus.objects.get_default_initial()
order = order_creator.create_order(basket)
packages_from_source = packager.pack_source(basket)
packages_from_order = packager.pack_order(order)
# os produtos cabem todos no mesmo pacote
assert len(packages_from_source) == 1
assert len(packages_from_order) == 1
pkge_from_source = packages_from_source[0]
pkge_from_order = packages_from_order[0]
for pkge in (pkge_from_source, pkge_from_order):
assert pkge.count == 5 # 5 produtos
assert pkge.weight == (product1.gross_weight * 2 +
product2.gross_weight * 3) # peso igual
assert pkge.width == 500 # product2 width
assert pkge.length == 200 # product1 depth
assert pkge.height == (product1.height * 2 + product2.height * 3
) # soma as alturas
