def test_custom_payment_processor_cash_service(choice_identifier, expected_payment_status): shop = get_default_shop() product = get_default_product() supplier = get_default_supplier() processor = CustomPaymentProcessor.objects.create() payment_method = PaymentMethod.objects.create( shop=shop, payment_processor=processor, choice_identifier=choice_identifier, tax_class=get_default_tax_class()) order = create_order_with_product( product=product, supplier=supplier, quantity=1, taxless_base_unit_price=Decimal('5.55'), shop=shop) order.taxful_total_price = TaxfulPrice(Decimal('5.55'), u'EUR') order.payment_method = payment_method order.save() assert order.payment_status == PaymentStatus.NOT_PAID processor.process_payment_return_request(choice_identifier, order, None) assert order.payment_status == expected_payment_status processor.process_payment_return_request(choice_identifier, order, None) assert order.payment_status == expected_payment_status
def test_order_package_children_taxes(): """ Test OrderCreator creates package parent links for child lines. """ tax_class = get_default_tax_class() tax = Tax.objects.create(rate='0.25', name="Da Tax") TaxRule.objects.create(tax=tax).tax_classes.add(tax_class) source = get_order_source_with_a_package() assert source.get_lines()[0].tax_class == tax_class order = OrderCreator().create_order(source) lines_and_taxes = [] for line in order.lines.all(): lines_and_taxes.append(prettify_order_line(line)) for line_tax in line.taxes.all(): lines_and_taxes.append(' %s' % (line_tax,)) assert lines_and_taxes == [ '#0 10 x PackageParent', ' Da Tax: 20.000000000 EUR on 80.000000000 EUR', '#1 10 x PackageChild-0, child of #0', '#2 20 x PackageChild-1, child of #0', '#3 30 x PackageChild-2, child of #0', '#4 40 x PackageChild-3, child of #0', ]
def test_order_package_children_taxes(): """ Test OrderCreator creates package parent links for child lines. """ tax_class = get_default_tax_class() tax = Tax.objects.create(rate='0.25', name="Da Tax") TaxRule.objects.create(tax=tax).tax_classes.add(tax_class) source = get_order_source_with_a_package() assert source.get_lines()[0].tax_class == tax_class order = OrderCreator().create_order(source) lines_and_taxes = [] for line in order.lines.all(): lines_and_taxes.append(prettify_order_line(line)) for line_tax in line.taxes.all(): lines_and_taxes.append(' %s' % (line_tax, )) assert lines_and_taxes == [ '#0 10 x PackageParent', ' Da Tax: 20.000000000 EUR on 80.000000000 EUR', '#1 10 x PackageChild-0, child of #0', '#2 20 x PackageChild-1, child of #0', '#3 30 x PackageChild-2, child of #0', '#4 40 x PackageChild-3, child of #0', ]
def test_method_creation(rf, admin_user, view, model, service_provider_attr, get_provider): """ To make things little bit more simple let's use only english as an language. """ with override_settings(LANGUAGES=[("en", "en")]): view = view.as_view() service_provider_field = "base-%s" % service_provider_attr data = { service_provider_field: get_provider().id, "base-choice_identifier": "manual", "base-name__en": "Custom method", "base-shop": get_default_shop().id, "base-tax_class": get_default_tax_class().id, "base-enabled": True, } # Default provider CustomCarrier/CustomPaymentProcessor should be set in form init methods_before = model.objects.count() url = "/?provider=%s" % get_provider().id request = apply_request_middleware(rf.post(url, data=data), user=admin_user) response = view(request, pk=None) if hasattr(response, "render"): response.render() assert response.status_code in [200, 302] assert model.objects.count() == (methods_before + 1)
def test_weight_limits(): sm = ShippingMethod(tax_class=get_default_tax_class()) sm.module_data = {"min_weight": "100", "max_weight": "500"} source = BasketishOrderSource(get_default_shop()) assert any(ve.code == "min_weight" for ve in sm.get_validation_errors(source)) source.add_line(type=OrderLineType.PRODUCT, weight=600) assert any(ve.code == "max_weight" for ve in sm.get_validation_errors(source))
def test_limited_methods(): """ Test that products can declare that they limit available shipping methods. """ unique_shipping_method = ShippingMethod(tax_class=get_default_tax_class(), module_data={"price": 0}) unique_shipping_method.save() shop = get_default_shop() common_product = create_product(sku="SH_COMMON", shop=shop) # A product that does not limit shipping methods unique_product = create_product(sku="SH_UNIQUE", shop=shop) # A product that only supports unique_shipping_method unique_shop_product = unique_product.get_shop_instance(shop) unique_shop_product.limit_shipping_methods = True unique_shop_product.shipping_methods.add(unique_shipping_method) unique_shop_product.save() impossible_product = create_product(sku="SH_IMP", shop=shop) # A product that can't be shipped at all imp_shop_product = impossible_product.get_shop_instance(shop) imp_shop_product.limit_shipping_methods = True imp_shop_product.save() for product_ids, method_ids in [ ((common_product.pk, unique_product.pk), (unique_shipping_method.pk,)), ((common_product.pk,), ShippingMethod.objects.values_list("pk", flat=True)), ((unique_product.pk,), (unique_shipping_method.pk,)), ((unique_product.pk, impossible_product.pk,), ()), ((common_product.pk, impossible_product.pk,), ()), ]: product_ids = set(product_ids) assert ShippingMethod.objects.available_ids(shop=shop, products=product_ids) == set(method_ids)
def test_process_payment_return_request(rf): """ Order payment with default payment method with ``CustomPaymentProcessor`` should be deferred. Payment can't be processed if method doesn't have provider or provider is not enabled or payment method is not enabled. """ pm = PaymentMethod.objects.create( shop=get_default_shop(), name="Test method", enabled=False, tax_class=get_default_tax_class()) order = create_empty_order() order.payment_method = pm order.save() assert order.payment_status == PaymentStatus.NOT_PAID with pytest.raises(ValueError): # Can't process payment with unusable method order.payment_method.process_payment_return_request(order, rf.get("/")) assert order.payment_status == PaymentStatus.NOT_PAID pm.payment_processor = get_custom_payment_processor() pm.payment_processor.enabled = False pm.save() with pytest.raises(ValueError): # Can't process payment with unusable method order.payment_method.process_payment_return_request(order, rf.get("/")) assert order.payment_status == PaymentStatus.NOT_PAID pm.payment_processor.enabled = True pm.save() with pytest.raises(ValueError): # Can't process payment with unusable method order.payment_method.process_payment_return_request(order, rf.get("/")) assert order.payment_status == PaymentStatus.NOT_PAID pm.enabled = True pm.save() order.payment_method.process_payment_return_request(order, rf.get("/")) assert order.payment_status == PaymentStatus.DEFERRED
def get_expensive_sweden_shipping_method(): sm = ShippingMethod( identifier=ExpensiveSwedenShippingModule.identifier, module_identifier=ExpensiveSwedenShippingModule.identifier, tax_class=get_default_tax_class(), ) sm.module_data = {"min_weight": "0.11000000", "max_weight": "3.00000000", "price_waiver_product_minimum": "370"} sm.save() return sm
def test_service_methods_with_long_name(rf): """ Make sure that service methods with long names (up to the max length of shipping or payment method names) don't cause exceptions when creating an order. """ MAX_LENGTH = 100 long_name = "X" * MAX_LENGTH assert len(long_name) == MAX_LENGTH sm = ShippingMethod.objects.language("en").create( shop=get_default_shop(), name=long_name, enabled=True, tax_class=get_default_tax_class()) pm = PaymentMethod.objects.language("en").create( shop=get_default_shop(), name=long_name, enabled=True, tax_class=get_default_tax_class()) order = create_empty_order() order.shipping_method = sm order.payment_method = pm order.full_clean() order.save()
def _get_payment_method_with_phase(): processor = PaymentWithCheckoutPhase.objects.create( identifier="processor_with_phase", enabled=True) assert isinstance(processor, PaymentWithCheckoutPhase) return processor.create_service(None, identifier="payment_with_phase", shop=get_default_shop(), name="Test method with phase", enabled=True, tax_class=get_default_tax_class())
def _get_shipping_method_with_phase(): carrier = CarrierWithCheckoutPhase.objects.create( identifier="carrier_with_phase", enabled=True) assert isinstance(carrier, CarrierWithCheckoutPhase) return carrier.create_service(None, identifier="carrier_with_phase", shop=get_default_shop(), name="Test method with phase", enabled=True, tax_class=get_default_tax_class())
def test_methods(admin_user, country): contact = get_person_contact(admin_user) source = BasketishOrderSource( lines=[ SourceLine( type=OrderLineType.PRODUCT, product=get_default_product(), supplier=get_default_supplier(), quantity=1, unit_price=TaxlessPrice(10), weight=Decimal("0.2"), ) ] ) billing_address = get_address() shipping_address = get_address(name="Shippy Doge", country=country) source.shop = get_default_shop() source.billing_address = billing_address source.shipping_address = shipping_address source.customer = contact with override_provides_for_expensive_sweden_shipping_method(): source.shipping_method = get_expensive_sweden_shipping_method() source.payment_method = PaymentMethod.objects.create( identifier="neat", module_data={"price": 4}, tax_class=get_default_tax_class() ) assert source.shipping_method_id assert source.payment_method_id errors = list(source.get_validation_errors()) if ( country == "FI" ): # "Expenseefe-a Svedee Sheepping" will not allow shipping to Finland, let's see if that holds true assert any([ve.code == "we_no_speak_finnish" for ve in errors]) return # Shouldn't try the rest if we got an error here else: assert not errors final_lines = list(source.get_final_lines()) assert any(line.type == OrderLineType.SHIPPING for line in final_lines) # TODO: (TAX) for some reason SourceLine.taxless_total_price property has been removed # I think it should be implemented back like in OrderLine / janne for line in final_lines: if line.type == OrderLineType.SHIPPING: if country == "SE": # We _are_ using Expenseefe-a Svedee Sheepping after all. assert line.taxless_total_price == TaxlessPrice("5.00") else: assert line.taxless_total_price == TaxlessPrice("4.00") assert line.text == u"Expenseefe-a Svedee Sheepping" if line.type == OrderLineType.PAYMENT: assert line.taxless_total_price == TaxlessPrice("4")
def _get_payment_method_with_phase(): processor = PaymentWithCheckoutPhase.objects.create( identifier="processor_with_phase", enabled=True) assert isinstance(processor, PaymentWithCheckoutPhase) return processor.create_service( None, identifier="payment_with_phase", shop=get_default_shop(), name="Test method with phase", enabled=True, tax_class=get_default_tax_class())
def _get_shipping_method_with_phase(): carrier = CarrierWithCheckoutPhase.objects.create( identifier="carrier_with_phase", enabled=True) assert isinstance(carrier, CarrierWithCheckoutPhase) return carrier.create_service( None, identifier="carrier_with_phase", shop=get_default_shop(), name="Test method with phase", enabled=True, tax_class=get_default_tax_class())
def get_expensive_sweden_shipping_method(): sm = ShippingMethod( identifier=ExpensiveSwedenShippingModule.identifier, module_identifier=ExpensiveSwedenShippingModule.identifier, tax_class=get_default_tax_class()) sm.module_data = { "min_weight": "0.11000000", "max_weight": "3.00000000", "price_waiver_product_minimum": "370" } sm.save() return sm
def test_weight_limits(): carrier = CustomCarrier.objects.create() sm = carrier.create_service( None, shop=get_default_shop(), enabled=True, tax_class=get_default_tax_class()) sm.behavior_components.add( WeightLimitsBehaviorComponent.objects.create( min_weight=100, max_weight=500)) source = BasketishOrderSource(get_default_shop()) assert any(ve.code == "min_weight" for ve in sm.get_unavailability_reasons(source)) source.add_line(type=OrderLineType.PRODUCT, weight=600) assert any(ve.code == "max_weight" for ve in sm.get_unavailability_reasons(source))
def get_expensive_sweden_shipping_method(): carrier = CustomCarrier.objects.create(name="Sveede Sheep") sm = carrier.create_service( None, shop=get_default_shop(), enabled=True, tax_class=get_default_tax_class(), name="Expenseefe-a Svedee Sheepping") sm.behavior_components.add( ExpensiveSwedenBehaviorComponent.objects.create(), WeightLimitsBehaviorComponent.objects.create( min_weight="0.11", max_weight="3"), ) return sm
def test_waiver(): sm = ShippingMethod( name="Waivey", tax_class=get_default_tax_class(), module_data={"price_waiver_product_minimum": "370", "price": "100"}, ) source = BasketishOrderSource() assert not source.prices_include_tax() assert sm.get_effective_name(source) == u"Waivey" assert sm.get_effective_price(source) == TaxlessPrice(100) source.lines = [ SourceLine(type=OrderLineType.PRODUCT, product=get_default_product(), unit_price=TaxlessPrice(400), quantity=1) ] assert sm.get_effective_price(source) == TaxlessPrice(0)
def test_methods(admin_user, country): contact = get_person_contact(admin_user) source = BasketishOrderSource(lines=[ SourceLine(type=OrderLineType.PRODUCT, product=get_default_product(), supplier=get_default_supplier(), quantity=1, unit_price=TaxlessPrice(10), weight=Decimal("0.2")) ]) billing_address = get_address() shipping_address = get_address(name="Shippy Doge", country=country) source.shop = get_default_shop() source.billing_address = billing_address source.shipping_address = shipping_address source.customer = contact with override_provides_for_expensive_sweden_shipping_method(): source.shipping_method = get_expensive_sweden_shipping_method() source.payment_method = PaymentMethod.objects.create( identifier="neat", module_data={"price": 4}, tax_class=get_default_tax_class()) assert source.shipping_method_id assert source.payment_method_id errors = list(source.get_validation_errors()) if country == "FI": # "Expenseefe-a Svedee Sheepping" will not allow shipping to Finland, let's see if that holds true assert any([ve.code == "we_no_speak_finnish" for ve in errors]) return # Shouldn't try the rest if we got an error here else: assert not errors final_lines = list(source.get_final_lines()) assert any(line.type == OrderLineType.SHIPPING for line in final_lines) # TODO: (TAX) for some reason SourceLine.taxless_total_price property has been removed # I think it should be implemented back like in OrderLine / janne for line in final_lines: if line.type == OrderLineType.SHIPPING: if country == "SE": # We _are_ using Expenseefe-a Svedee Sheepping after all. assert line.taxless_total_price == TaxlessPrice("5.00") else: assert line.taxless_total_price == TaxlessPrice("4.00") assert line.text == u"Expenseefe-a Svedee Sheepping" if line.type == OrderLineType.PAYMENT: assert line.taxless_total_price == TaxlessPrice("4")
def test_waiver(): sm = ShippingMethod(name="Waivey", tax_class=get_default_tax_class(), module_data={ "price_waiver_product_minimum": "370", "price": "100" }) source = BasketishOrderSource(get_default_shop()) assert sm.get_effective_name(source) == u"Waivey" assert sm.get_effective_price_info(source).price == source.shop.create_price(100) source.add_line( type=OrderLineType.PRODUCT, product=get_default_product(), base_unit_price=source.shop.create_price(400), quantity=1 ) assert sm.get_effective_price_info(source).price == source.shop.create_price(0)
def test_tax_edit_view_works_at_all(rf, admin_user): get_default_shop() # We need a shop to exists request = apply_request_middleware(rf.get("/")) request.user = admin_user default_tax_class = get_default_tax_class() with replace_modules([TaxModule]): with admin_only_urls(): view_func = TaxClassEditView.as_view() response = view_func(request, pk=default_tax_class.pk) response.render() assert (default_tax_class.name in force_text(response.content)) response = view_func(request, pk=None) # "new mode" response.render() assert response.content
def test_basket_campaign_case2(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() # create a basket rule that requires atleast value of 200 rule = BasketTotalAmountCondition.objects.create(value="200") single_product_price = "50" discount_amount_value = "10" unique_shipping_method = ShippingMethod(tax_class=get_default_tax_class(), module_data={"price": 50}) unique_shipping_method.save() for x in range(3): product = create_product( printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price ) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert basket.product_count == 3 campaign = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", discount_amount_value=discount_amount_value, active=True ) campaign.conditions.add(rule) campaign.save() assert len(basket.get_final_lines()) == 3 assert basket.total_price == price(single_product_price) * basket.product_count # check that shipping method affects campaign basket.shipping_method = unique_shipping_method basket.save() basket.uncache() assert len(basket.get_final_lines()) == 4 # Shipping should not affect the rule being triggered line_types = [l.type for l in basket.get_final_lines()] assert OrderLineType.DISCOUNT not in line_types product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert len(basket.get_final_lines()) == 6 # Discount included assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()]
def test_waiver(): sm = ShippingMethod(name="Waivey", tax_class=get_default_tax_class(), module_data={ "price_waiver_product_minimum": "370", "price": "100" }) source = BasketishOrderSource(get_default_shop()) assert sm.get_effective_name(source) == u"Waivey" assert sm.get_effective_price_info( source).price == source.shop.create_price(100) source.add_line(type=OrderLineType.PRODUCT, product=get_default_product(), base_unit_price=source.shop.create_price(400), quantity=1) assert sm.get_effective_price_info( source).price == source.shop.create_price(0)
def test_waiver(): sm = ShippingMethod(name="Waivey", tax_class=get_default_tax_class(), module_data={ "price_waiver_product_minimum": "370", "price": "100" }) source = BasketishOrderSource() assert not source.prices_include_tax() assert sm.get_effective_name(source) == u"Waivey" assert sm.get_effective_price(source) == TaxlessPrice(100) source.lines = [ SourceLine(type=OrderLineType.PRODUCT, product=get_default_product(), unit_price=TaxlessPrice(400), quantity=1) ] assert sm.get_effective_price(source) == TaxlessPrice(0)
def test_limited_methods(): """ Test that products can declare that they limit available shipping methods. """ unique_shipping_method = ShippingMethod(tax_class=get_default_tax_class(), module_data={"price": 0}) unique_shipping_method.save() shop = get_default_shop() common_product = create_product( sku="SH_COMMON", shop=shop) # A product that does not limit shipping methods unique_product = create_product( sku="SH_UNIQUE", shop=shop) # A product that only supports unique_shipping_method unique_shop_product = unique_product.get_shop_instance(shop) unique_shop_product.limit_shipping_methods = True unique_shop_product.shipping_methods.add(unique_shipping_method) unique_shop_product.save() impossible_product = create_product( sku="SH_IMP", shop=shop) # A product that can't be shipped at all imp_shop_product = impossible_product.get_shop_instance(shop) imp_shop_product.limit_shipping_methods = True imp_shop_product.save() for product_ids, method_ids in [ ((common_product.pk, unique_product.pk), (unique_shipping_method.pk, )), ((common_product.pk, ), ShippingMethod.objects.values_list("pk", flat=True)), ((unique_product.pk, ), (unique_shipping_method.pk, )), (( unique_product.pk, impossible_product.pk, ), ()), (( common_product.pk, impossible_product.pk, ), ()), ]: product_ids = set(product_ids) assert ShippingMethod.objects.available_ids( shop=shop, products=product_ids) == set(method_ids)
def test_order_flow_with_payment_phase(): create_default_order_statuses() n_orders_pre = Order.objects.count() populate_if_required() c = SmartClient() _populate_client_basket(c) # Create methods shipping_method = get_default_shipping_method() processor = PaymentWithCheckoutPhase.objects.create(identifier="processor_with_phase", enabled=True) assert isinstance(processor, PaymentWithCheckoutPhase) payment_method = processor.create_service( None, identifier="payment_with_phase", shop=get_default_shop(), name="Test method with phase", enabled=True, tax_class=get_default_tax_class(), ) # Resolve paths addresses_path = reverse("shoop:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shoop:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shoop:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shoop: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" 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 == 302, "Confirm should first redirect forth" assert response.url.endswith(payment_path) # Phase: Payment c.soup(payment_path) response = c.post(payment_path, data={"will_pay": False}) assert response.status_code == 200, "Invalid payment form should return error" response = c.post(payment_path, data={"will_pay": True}) assert response.status_code == 302, "Valid payment form should redirect forth" assert response.url.endswith(confirm_path) # Phase: Confirm 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" # response.url should point to payment, checked below # Check resulting order and its contents n_orders_post = Order.objects.count() assert n_orders_post > n_orders_pre, "order was created" order = Order.objects.filter(payment_method=payment_method).first() assert order.payment_data.get("promised_to_pay") assert order.payment_status == PaymentStatus.NOT_PAID # Resolve order specific paths (payment and complete) process_payment_path = reverse("shoop:order_process_payment", kwargs={"pk": order.pk, "key": order.key}) process_payment_return_path = reverse( "shoop:order_process_payment_return", kwargs={"pk": order.pk, "key": order.key} ) order_complete_path = reverse("shoop: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_basket_campaign_case2(rf): request, shop, group = initialize_test(rf, False) price = shop.create_price basket = get_basket(request) supplier = get_default_supplier() # create a basket rule that requires at least value of 200 rule = BasketTotalAmountCondition.objects.create(value="200") single_product_price = "50" discount_amount_value = "10" unique_shipping_method = ShippingMethod(tax_class=get_default_tax_class(), module_data={"price": 50}) unique_shipping_method.save() for x in range(3): product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert basket.product_count == 3 campaign = BasketCampaign.objects.create( shop=shop, public_name="test", name="test", discount_amount_value=discount_amount_value, active=True) campaign.conditions.add(rule) campaign.save() assert len(basket.get_final_lines()) == 3 assert basket.total_price == price( single_product_price) * basket.product_count # check that shipping method affects campaign basket.shipping_method = unique_shipping_method basket.save() basket.uncache() assert len(basket.get_final_lines() ) == 4 # Shipping should not affect the rule being triggered line_types = [l.type for l in basket.get_final_lines()] assert OrderLineType.DISCOUNT not in line_types product = create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price=single_product_price) basket.add_product(supplier=supplier, shop=shop, product=product, quantity=1) assert len(basket.get_final_lines()) == 6 # Discount included assert OrderLineType.DISCOUNT in [l.type for l in basket.get_final_lines()]
def test_order_flow_with_payment_phase(): create_default_order_statuses() n_orders_pre = Order.objects.count() populate_if_required() c = SmartClient() _populate_client_basket(c) # Create methods shipping_method = get_default_shipping_method() processor = PaymentWithCheckoutPhase.objects.create( identifier="processor_with_phase", enabled=True) assert isinstance(processor, PaymentWithCheckoutPhase) payment_method = processor.create_service( None, identifier="payment_with_phase", shop=get_default_shop(), name="Test method with phase", enabled=True, tax_class=get_default_tax_class()) # Resolve paths addresses_path = reverse("shoop:checkout", kwargs={"phase": "addresses"}) methods_path = reverse("shoop:checkout", kwargs={"phase": "methods"}) payment_path = reverse("shoop:checkout", kwargs={"phase": "payment"}) confirm_path = reverse("shoop: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" 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 == 302, "Confirm should first redirect forth" assert response.url.endswith(payment_path) # Phase: Payment c.soup(payment_path) response = c.post(payment_path, data={"will_pay": False}) assert response.status_code == 200, "Invalid payment form should return error" response = c.post(payment_path, data={"will_pay": True}) assert response.status_code == 302, "Valid payment form should redirect forth" assert response.url.endswith(confirm_path) # Phase: Confirm 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" # response.url should point to payment, checked below # Check resulting order and its contents n_orders_post = Order.objects.count() assert n_orders_post > n_orders_pre, "order was created" order = Order.objects.filter(payment_method=payment_method).first() assert order.payment_data.get("promised_to_pay") assert order.payment_status == PaymentStatus.NOT_PAID # Resolve order specific paths (payment and complete) process_payment_path = reverse("shoop:order_process_payment", kwargs={ "pk": order.pk, "key": order.key }) process_payment_return_path = reverse("shoop:order_process_payment_return", kwargs={ "pk": order.pk, "key": order.key }) order_complete_path = reverse("shoop: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