def test_package(): shop = get_default_shop() supplier = get_default_supplier() package_product = create_product("PackageParent", shop=shop, supplier=supplier) assert not package_product.get_package_child_to_quantity_map() children = [create_product("PackageChild-%d" % x, shop=shop, supplier=supplier) for x in range(4)] package_def = {child: 1 + i for (i, child) in enumerate(children)} package_product.make_package(package_def) assert package_product.mode == ProductMode.PACKAGE_PARENT package_product.save() sp = package_product.get_shop_instance(shop) assert not list(sp.get_orderability_errors(supplier=supplier, quantity=1, customer=AnonymousContact())) with pytest.raises(ValueError): # Test re-packaging fails package_product.make_package(package_def) # Check that OrderCreator can deal with packages source = BasketishOrderSource() source.lines.append(SourceLine( type=OrderLineType.PRODUCT, product=package_product, supplier=get_default_supplier(), quantity=10, unit_price=TaxlessPrice(10), )) source.shop = get_default_shop() source.status = get_initial_order_status() creator = OrderCreator(request=None) order = creator.create_order(source) pids_to_quantities = order.get_product_ids_and_quantities() for child, quantity in six.iteritems(package_def): assert pids_to_quantities[child.pk] == 10 * quantity
def test_user_will_be_redirected_to_user_account_page_after_activation(client): """ 1. Register user 2. Dig out the urls from the email 3. Get the url and see where it redirects 4. See that user's email is in content (in input) 5. Check that the url poins to user_account-page """ if "shoop.front.apps.registration" not in settings.INSTALLED_APPS: pytest.skip("shoop.front.apps.registration required in installed apps") if "shoop.front.apps.customer_information" not in settings.INSTALLED_APPS: pytest.skip("shoop.front.apps.customer_information required in installed apps") get_default_shop() response = client.post(reverse("shoop:registration_register"), data={ "username": username, "email": email, "password1": "password", "password2": "password", }, follow=True) body = mail.outbox[-1].body urls = re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', body) response = client.get(urls[0], follow=True) assert email.encode('utf-8') in response.content, 'email should be found from the page.' assert reverse('shoop:customer_edit') == response.request['PATH_INFO'], 'user should be on the account-page.'
def test_services_edit_view_formsets(rf, admin_user, view, get_object): get_default_shop() object = get_object() request = apply_request_middleware(rf.get("/"), user=admin_user) form_parts = get_form_parts(request, view, object) # form parts should include forms, form parts and plus one for the base form assert len(form_parts) == (len(DEFAULT_BEHAVIOR_FORMS) + len(DEFAULT_BEHAVIOR_FORM_PARTS) + 1)
def test_contact_details_view_with_many_groups(rf, admin_user): get_default_shop() person = create_random_person() person.groups.add( ContactGroup.objects.create(name="Czz Group"), ContactGroup.objects.create(name="Azz Group"), ContactGroup.objects.create(name="Bzz Group"), ContactGroup.objects.language('fi').create(name="Dzz ryhmä"), ) # Group with name in two languages grp_e = ContactGroup.objects.language('en').create(name="Ezz Group") grp_e.set_current_language('fi') grp_e.name = "Ezz ryhmä" grp_e.save() person.groups.add(grp_e) request = apply_request_middleware(rf.get("/"), user=admin_user) with translation.override('en'): view_func = ContactDetailView.as_view() response = view_func(request, pk=person.pk) content = response.render().content.decode('utf-8') assert "Azz Group" in content assert "Bzz Group" in content assert "Czz Group" in content assert "Dzz ryhmä" in content, "no name in active language, still present" assert "Ezz Group" in content, "rendered with active language" positions = [content.index(x + "zz ") for x in 'ABCDE'] assert positions == sorted(positions), "Groups are sorted" assert response.status_code == 200
def test_rules_and_effects(rf, admin_user): """ To make things little bit more simple let's use only english as a language. """ get_default_shop() with override_settings(LANGUAGES=[("en", "en")]): shop = get_default_shop() object = BasketCampaign.objects.create(name="test campaign", active=True, shop=shop) assert object.conditions.count() == 0 assert object.effects.count() == 0 view = BasketCampaignEditView.as_view() data = { "base-name": "test campaign", "base-public_name__en": "Test Campaign", "base-shop": get_default_shop().id, "base-active": True, "base-basket_line_text": "Test campaign activated!" } with override_provides( "campaign_basket_condition", ["shoop.campaigns.admin_module.forms:BasketTotalProductAmountConditionForm"]): with override_provides( "basket_campaign_effect", ["shoop.campaigns.admin_module.forms:BasketDiscountAmountForm"]): data.update(get_products_in_basket_data()) data.update(get_free_product_data(object)) request = apply_request_middleware(rf.post("/", data=data), user=admin_user) view(request, pk=object.pk) object.refresh_from_db() assert object.conditions.count() == 1 assert object.effects.count() == 1
def test_order_creator_view_for_customer(rf, admin_user): get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) request = apply_request_middleware(rf.get("/", {"contact_id": contact.id}), user=admin_user) response = OrderEditView.as_view()(request) assert_contains(response, "customerData") # in the config assert_contains(response, "isCompany") # in the config
def test_behavior_delete_save(rf, admin_user, view, model, get_object, service_provider_attr): """ Only testing one initial behavior component """ get_default_shop() with override_settings(LANGUAGES=[("en", "en")]): object = get_object() view = view.as_view() service_provider_attr_field = "base-%s" % service_provider_attr component = WeightLimitsBehaviorComponent.objects.create(min_weight=0, max_weight=1) object.behavior_components.add(component) components_before = object.behavior_components.count() assert components_before == 1 data = get_default_data(object, service_provider_attr, service_provider_attr_field, delete=True) data["weightlimitsbehaviorcomponent-0-id"] = component.id data["weightlimitsbehaviorcomponent-INITIAL_FORMS"] = 1 data["weightlimitsbehaviorcomponent-TOTAL_FORMS"] = 2 request = apply_request_middleware(rf.post("/", data=data, user=admin_user)) response = view(request, pk=object.pk) if hasattr(response, "render"): response.render() components_after = object.behavior_components.count() assert not components_after assert not WaivingCostBehaviorComponent.objects.first()
def test_customer_edit_redirects_to_login_if_not_logged_in(): get_default_shop() # Front middleware needs a Shop to exists urls = ["shoop:customer_edit", "shoop:company_edit"] for url in urls: response = SmartClient().get(reverse(url), follow=False) assert response.status_code == 302 # Redirection ("Found") assert resolve_url(settings.LOGIN_URL) in response.url
def test_editing_sales_ranges_multi_shop(rf, admin_user): get_default_shop() another_shop = get_shop(prices_include_tax=True) another_shop.status = ShopStatus.ENABLED another_shop.save() group = get_default_customer_group() data = {} for shop in Shop.objects.all(): data.update(get_edit_view_data(shop, group, 0, 50)) assert ContactGroupSalesRange.objects.count() == 0 # To make this test work we need to mock members form_part since the extra # forms does not render correctly with patch.object(ContactGroupEditView, "base_form_part_classes", [ContactGroupBaseFormPart]): request = apply_request_middleware(rf.post("/", data=data), user=admin_user) view = ContactGroupEditView.as_view() response = view(request=request, pk=group.pk) if hasattr(response, "render"): response.render() assert response.status_code in [200, 302] assert ContactGroupSalesRange.objects.count() == 2 for shop in Shop.objects.all(): sales_range = ContactGroupSalesRange.objects.filter(group=group, shop=shop).first() assert sales_range.min_value == 0 assert sales_range.max_value == 50
def test_category_links_plugin_with_customer(rf, show_all_categories): """ Test plugin for categories that is visible for certain group """ shop = get_default_shop() group = get_default_customer_group() customer = create_random_person() customer.groups.add(group) customer.save() request = rf.get("/") request.shop = get_default_shop() apply_request_middleware(request) request.customer = customer category = get_default_category() category.status = CategoryStatus.VISIBLE category.visibility = CategoryVisibility.VISIBLE_TO_GROUPS category.visibility_groups.add(group) category.shops.add(shop) category.save() vars = {"request": request} context = get_jinja_context(**vars) plugin = CategoryLinksPlugin({"categories": [category.pk], "show_all_categories": show_all_categories}) assert category.is_visible(customer) assert category in plugin.get_context_data(context)["categories"] customer_without_groups = create_random_person() customer_without_groups.groups.clear() assert not category.is_visible(customer_without_groups) request.customer = customer_without_groups context = get_jinja_context(**vars) assert category not in plugin.get_context_data(context)["categories"]
def test_login_inactive_user_fails(client, regular_user, rf): if "shoop.front.apps.auth" not in settings.INSTALLED_APPS: pytest.skip("Need shoop.front.apps.auth in INSTALLED_APPS") get_default_shop() prepare_user(regular_user) response = client.post(reverse("shoop:login"), data={ "username": regular_user.username, "password": REGULAR_USER_PASSWORD, }) request = rf.get("/") request.session = client.session assert get_user(request) == regular_user, "User is logged in" request = rf.get("/") request.session = client.session logout(request) user_contact = regular_user.contact assert user_contact.is_active user_contact.is_active = False user_contact.save() client.post(reverse("shoop:login"), data={ "username": regular_user.username, "password": REGULAR_USER_PASSWORD, }) request = rf.get("/") request.session = client.session assert get_user(request).is_anonymous(), "User is still anonymous"
def test_login_with_email_3(client, regular_user, rf): if "shoop.front.apps.auth" not in settings.INSTALLED_APPS: pytest.skip("Need shoop.front.apps.auth in INSTALLED_APPS") new_user_password = "******" new_user = get_user_model().objects.create_user( username=regular_user.email, password=new_user_password, email=regular_user.email ) get_default_shop() prepare_user(regular_user) redirect_target = "/redirect-success/" # Login with new_user username should work even if there is users with same email response = client.post(reverse("shoop:login"), data={ "username": regular_user.email, "password": new_user_password, REDIRECT_FIELD_NAME: redirect_target }) assert response.get("location") assert response.get("location").endswith(redirect_target) request = rf.get("/") request.session = client.session assert get_user(request) == new_user, "User is logged in"
def test_campaign_end_date(rf, admin_user): """ To make things little bit more simple let's use only english as a language. """ with override_settings(LANGUAGES=[("en", "en")]): shop = get_default_shop() old_name = "test_campaign" object = CatalogCampaign.objects.create(name=old_name, active=True, shop=shop) object.save() view = CatalogCampaignEditView.as_view() new_name = "Test Campaign" assert object.name != new_name data = { "base-name": new_name, "base-public_name__en": "Test Campaign", "base-shop": get_default_shop().id, "base-active": True, "base-basket_line_text": "Test campaign activated!", "base-start_datetime": datetime.datetime(year=2016, month=6, day=19), "base-end_datetime": datetime.datetime(year=2016, month=6, day=10) } methods_before = CatalogCampaign.objects.count() # Conditions, effects and effects is tested separately with override_provides("campaign_context_condition", []): with override_provides("campaign_catalog_filter", []): with override_provides("catalog_campaign_effect", []): request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request, pk=object.pk) assert response.status_code in [200, 302] content = response.render().content.decode("utf-8") assert "Campaign end date can't be before start date." in content assert CatalogCampaign.objects.count() == methods_before assert CatalogCampaign.objects.get(pk=object.pk).name == old_name
def test_campaign_edit_save(rf, admin_user): """ To make things little bit more simple let's use only english as a language. """ with override_settings(LANGUAGES=[("en", "en")]): shop = get_default_shop() object = BasketCampaign.objects.create(name="test campaign", active=True, shop=shop) object.save() view = BasketCampaignEditView.as_view() new_name = "Test Campaign" assert object.name != new_name data = { "base-name": new_name, "base-public_name__en": "Test Campaign", "base-shop": get_default_shop().id, "base-active": True, "base-basket_line_text": "Test campaign activated!" } methods_before = BasketCampaign.objects.count() # Conditions and effects is tested separately with override_provides("campaign_basket_condition", []): with override_provides("basket_campaign_effect", []): request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request, pk=object.pk) assert response.status_code in [200, 302] assert BasketCampaign.objects.count() == methods_before assert BasketCampaign.objects.get(pk=object.pk).name == new_name
def test_campaign_new_mode_view_formsets(rf, admin_user): view = CatalogCampaignEditView get_default_shop() request = apply_request_middleware(rf.get("/"), user=admin_user) form_parts = get_form_parts(request, view, view.model()) assert len(form_parts) == 1 assert issubclass(form_parts[0].__class__, CatalogBaseFormPart)
def test_user_detail_contact_seed(rf): get_default_shop() contact = create_random_person() view_func = UserDetailView.as_view() # Check that fields populate . . . request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk})) response = view_func(request) response.render() content = force_text(response.content) assert force_text(contact.first_name) in content assert force_text(contact.last_name) in content assert force_text(contact.email) in content # POST the password too to create the user . . . post = extract_form_fields(BeautifulSoup(content)) post["password"] = "******" request.method = "POST" request.POST = post response = view_func(request) assert response.status_code < 500 # Check this new user is visible in the details now user = Contact.objects.get(pk=contact.pk).user request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk})) response = view_func(request, pk=user.pk) response.render() content = force_text(response.content) assert force_text(contact.first_name) in content assert force_text(contact.last_name) in content assert force_text(contact.email) in content
def test_new_service_providers_type_select(rf, admin_user, sp_model, type_param): """ Test `ServiceProvideEditView`` with different types of ``ServiceProvider`` subclasses. Make sure that view is rendered and creating new object works. To make things little bit more simple let's use only english as an language. """ with override_settings(LANGUAGES=[("en", "en")]): get_default_shop() view = ServiceProviderEditView.as_view() url = "/" if type_param: url += "?type=%s" % type_param soup = get_bs_object_for_view(rf.get(url), view, admin_user) selected_type = soup.find("select", attrs={"id": "id_type"}).find("option", selected=True)["value"] if type_param: assert type_param == selected_type else: assert selected_type in [ "shoop.customcarrier", "shoop.custompaymentprocessor", "shoop_testing.pseudopaymentprocessor" ] if sp_model: name = "Some provider" data = { "type": type_param, "name__en": name, "enabled": True } provider_count = sp_model.objects.count() get_bs_object_for_view(rf.post(url, data=data), view, admin_user) assert sp_model.objects.count() == provider_count + 1
def test_user_detail_contact_seed(rf): get_default_shop() contact = create_random_person() # Using random data for name and email would need escaping when # checking if it is rendered, therefore use something very basic instead contact.name = "Matti Perustyyppi" contact.email = "*****@*****.**" contact.save() view_func = UserDetailView.as_view() # Check that fields populate . . . request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk})) response = view_func(request) response.render() content = force_text(response.content) assert force_text(contact.first_name) in content assert force_text(contact.last_name) in content assert force_text(contact.email) in content # POST the password too to create the user . . . post = extract_form_fields(BeautifulSoup(content)) post["password"] = "******" request.method = "POST" request.POST = post response = view_func(request) assert response.status_code < 500 # Check this new user is visible in the details now user = Contact.objects.get(pk=contact.pk).user request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk})) response = view_func(request, pk=user.pk) response.render() content = force_text(response.content) assert force_text(contact.first_name) in content assert force_text(contact.last_name) in content assert force_text(contact.email) in content
def get_request_with_basket(path="/", user=None, ajax=False): request = get_request() get_default_shop() # Create a Shop ShoopFrontMiddleware().process_request(request) request.session = {} if ajax: request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest' return request
def test_modules_in_core_admin_work(rf, admin_user): get_default_shop() request = rf.get("/") apply_request_middleware(request, user=admin_user) request = apply_request_middleware(rf.get("/"), user=admin_user) with replace_modules(ShoopAdminAppConfig.provides["admin_module"]): assert all(get_module_urls()) assert get_menu_entry_categories(request)
def test_simple_search_no_results(rf): with translation.override("xx"): # use built-in translation get_default_shop() view = SearchView.as_view() resp = view(apply_request_middleware(rf.get("/", {"q": UNLIKELY_STRING}))) assert NO_RESULTS_FOUND_STRING in resp.rendered_content resp = view(apply_request_middleware(rf.get("/"))) assert NO_RESULTS_FOUND_STRING not in resp.rendered_content
def test_superuser_can_see_invisible_page(rf, admin_user): page = create_page() get_default_shop() view_func = PageView.as_view() request = apply_request_middleware(rf.get("/"), user=admin_user) response = view_func(request, url=page.url) response.render() assert "<h1>Bacon ipsum" in response.rendered_content
def test_anon_cant_see_invisible_page(rf): page = create_page() get_default_shop() view_func = PageView.as_view() request = apply_request_middleware(rf.get("/")) assert request.user.is_anonymous() with pytest.raises(Http404): response = view_func(request, url=page.url)
def test_form_part_for_new_group(rf, admin_user): get_default_shop() request = apply_request_middleware(rf.get("/"), user=admin_user) initialized_view = ContactGroupEditView(request=request, kwargs={"pk": None}) initialized_view.object = initialized_view.get_object() # Just for test form_def_values = initialized_view.get_form().form_defs.values() assert [form_def for form_def in form_def_values if form_def.name == "base"] # contact_group_sales_ranges should not be in form defs assert not [form_def for form_def in form_def_values if "contact_group_sales_ranges" in form_def.name]
def test_visible_page_has_right_content(rf): page = create_page(available_from=datetime.date(1988, 1, 1)) get_default_shop() view_func = PageView.as_view() request = apply_request_middleware(rf.get("/")) assert request.user.is_anonymous() response = view_func(request, url=page.url) response.render() assert "<h1>Bacon ipsum" in response.rendered_content
def test_detail_view(rf, admin_user, model_and_class): get_default_shop() # obvious prerequisite model_func, class_spec = model_and_class model = model_func() view = load(class_spec).as_view() request = apply_request_middleware(rf.get("/"), user=admin_user) response = view(request, pk=model.pk) if hasattr(response, "render"): response.render() assert 200 <= response.status_code < 300
def test_order_creator_customer_data(rf, admin_user): get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) request = apply_request_middleware(rf.get("/", { "command": "customer_data", "id": contact.id }), user=admin_user) response = OrderCreateView.as_view()(request) assert_contains(response, "name") assert_contains(response, contact.name)
def test_intra_request_user_changing(rf, regular_user): get_default_shop() # Create a shop mw = ShoopFrontMiddleware() request = apply_request_middleware(rf.get("/"), user=regular_user) mw.process_request(request) assert request.person == shoop.core.models.get_person_contact(regular_user) logout(request) assert request.user == AnonymousUser() assert request.person == shoop.core.models.AnonymousContact() assert request.customer == shoop.core.models.AnonymousContact()
def test_product_page(client): get_default_shop() product = get_default_product() response = client.get( reverse('shoop:product', kwargs={ 'pk': product.pk, 'slug': product.slug } ) ) assert b'no such element' not in response.content, 'All items are not rendered correctly'
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 test_with_anonymous_user(): get_default_shop() # Create a shop mw = ShoopFrontMiddleware() request = get_unprocessed_request() mw.process_request(request) check_request_attribute_basics(request) assert isinstance(request.person, shoop.core.models.AnonymousContact) assert isinstance(request.customer, shoop.core.models.AnonymousContact) assert request.person == request.customer
def test_login_fails_without_valid_password(client, regular_user, rf): if "shoop.front.apps.auth" not in settings.INSTALLED_APPS: pytest.skip("Need shoop.front.apps.auth in INSTALLED_APPS") prepare_user(regular_user) get_default_shop() client.post(reverse("shoop:login"), data={ "username": regular_user.username, "password": "******" % REGULAR_USER_PASSWORD, }) request = rf.get("/") request.session = client.session assert get_user(request).is_anonymous(), "User is still anonymous"
def test_password_recovery_user_receives_email_1(client): get_default_shop() user = get_user_model().objects.create_user(username="******", password="******", email="*****@*****.**") n_outbox_pre = len(mail.outbox) client.post(reverse("shoop:recover_password"), data={"email": user.email}) assert (len(mail.outbox) == n_outbox_pre + 1), "Sending recovery email has failed" assert 'http' in mail.outbox[-1].body, "No recovery url in email" # ticket #SHOOP-606 assert 'site_name' not in mail.outbox[ -1].body, "site_name variable has no content"
def test_admin_recovers_clients_password(rf, admin_user): get_default_shop() person = create_random_person() person.user = get_user_model().objects.create_user( username="******", password="******", email="*****@*****.**" ) person.save() request = apply_request_middleware(rf.post("/"), user=admin_user) view_func = ContactResetPasswordView.as_view() n_outbox_pre = len(mail.outbox) view_func(request, pk=person.pk) # The response doesn't actually matter. assert (len(mail.outbox) == n_outbox_pre + 1), "Sending recovery email has failed"
def test_login_logs_the_user_in(client, regular_user, rf): if "shoop.front.apps.auth" not in settings.INSTALLED_APPS: pytest.skip("Need shoop.front.apps.auth in INSTALLED_APPS") get_default_shop() prepare_user(regular_user) client.post(reverse("shoop:login"), data={ "username": regular_user.username, "password": REGULAR_USER_PASSWORD, }) request = rf.get("/") request.session = client.session assert get_user(request) == regular_user, "User is logged in"
def test_with_logged_in_user(regular_user): get_default_shop() # Create a shop mw = ShoopFrontMiddleware() request = get_unprocessed_request() request.user = regular_user mw.process_request(request) check_request_attribute_basics(request) assert isinstance(request.person, PersonContact) assert isinstance(request.customer, PersonContact) assert request.person == request.customer
def test_login_with_email_2(client, regular_user, rf): if "shoop.front.apps.auth" not in settings.INSTALLED_APPS: pytest.skip("Need shoop.front.apps.auth in INSTALLED_APPS") # Create user with same email as regular user to fail login get_user_model().objects.create_user(username="******", password="******", email=regular_user.email) get_default_shop() prepare_user(regular_user) redirect_target = "/redirect-success/" client.post(reverse("shoop:login"), data={ "username": regular_user.email, "password": REGULAR_USER_PASSWORD, REDIRECT_FIELD_NAME: redirect_target }) request = rf.get("/") request.session = client.session assert get_user(request).is_anonymous(), "User is still anonymous" # Login with unknown email client.post(reverse("shoop:login"), data={ "username": "******", "password": REGULAR_USER_PASSWORD, REDIRECT_FIELD_NAME: redirect_target }) request = rf.get("/") request.session = client.session assert get_user(request).is_anonymous(), "User is still anonymous" # Login with username should work normally response = client.post(reverse("shoop:login"), data={ "username": regular_user.username, "password": REGULAR_USER_PASSWORD, REDIRECT_FIELD_NAME: redirect_target }) assert response.get("location") assert response.get("location").endswith(redirect_target) request = rf.get("/") request.session = client.session assert get_user(request) == regular_user, "User is logged in"
def test_with_inactive_contact(rf, regular_user, admin_user): get_default_shop() # Create a shop # Get or create contact for regular user contact = get_person_contact(regular_user) assert contact.is_active contact.is_active = False contact.save() request = apply_request_middleware(rf.get("/"), user=regular_user) mw = ShoopFrontMiddleware() mw.process_request(request) assert request.user == AnonymousUser() assert request.person == AnonymousContact() assert request.customer == AnonymousContact()
def test_multilanguage_page_redirect(rf): page = create_multilanguage_page(eternal=True, url="redirector") get_default_shop() view_func = PageView.as_view() request = apply_request_middleware(rf.get("/")) with translation.override("fi"): page.set_current_language("fi") finnish_url = page.url response = view_func(request, url=finnish_url) assert response.status_code == 200 # Using the Finnish URL works page.set_current_language("en") english_url = page.url response = view_func(request, url=english_url) assert response.status_code == 302 # Using the English URL - redirect to finnish assert finnish_url in response["location"]
def test_product_module_search(rf, admin_user): get_default_shop() request = apply_request_middleware(rf.get("/"), user=admin_user) with replace_modules([ProductModule]): with admin_only_urls(): default_product = get_default_product() model_url = get_model_url(default_product) sku = default_product.sku assert any(sr.url == model_url for sr in get_search_results( request, query=sku)) # Queries work assert any(sr.is_action for sr in get_search_results( request, query=sku[:5])) # Actions work assert empty_iterable(get_search_results( request, query=sku[:2])) # Short queries don't
def test_form_part_for_new_group(rf, admin_user): get_default_shop() request = apply_request_middleware(rf.get("/"), user=admin_user) initialized_view = ContactGroupEditView(request=request, kwargs={"pk": None}) initialized_view.object = initialized_view.get_object() # Just for test form_def_values = initialized_view.get_form().form_defs.values() assert [ form_def for form_def in form_def_values if form_def.name == "base" ] # contact_group_sales_ranges should not be in form defs assert not [ form_def for form_def in form_def_values if "contact_group_sales_ranges" in form_def.name ]
def test_limited_methods(): """ Test that products can declare that they limit available shipping methods. """ unique_shipping_method = get_shipping_method(name="unique", price=0) 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_multilanguage_page_404_no_xlate(rf): # https://github.com/edoburu/django-parler/issues/50 cache.clear( ) # this is here, because parler cache is enabled and tests use same pk with page page = create_multilanguage_page( eternal=True, url="no_content", languages=("udm", )) # create page with udm language get_default_shop() request = apply_request_middleware(rf.get("/")) with translation.override("fi"): # change language of the page to fi view_func = PageView.as_view() with pytest.raises(Http404): response = view_func( request, url="no_content-udm" ) # Using Udmurt URL, but xlate is Finnish . . . assert response.status_code == 404 # ... should 404
def test_translations_of_method_and_component(): sm = get_shipping_method(name="Unique shipping") sm.set_current_language('en') sm.name = "Shipping" sm.set_current_language('fi') sm.name = "Toimitus" sm.save() cost = FixedCostBehaviorComponent.objects.language('fi').create( price_value=10, description="kymppi") cost.set_current_language('en') cost.description = "ten bucks" cost.save() sm.behavior_components.add(cost) source = BasketishOrderSource(get_default_shop()) source.shipping_method = sm translation.activate('fi') shipping_lines = [ line for line in source.get_final_lines() if line.type == OrderLineType.SHIPPING] assert len(shipping_lines) == 1 assert shipping_lines[0].text == 'Toimitus: kymppi' translation.activate('en') source.uncache() shipping_lines = [ line for line in source.get_final_lines() if line.type == OrderLineType.SHIPPING] assert len(shipping_lines) == 1 assert shipping_lines[0].text == 'Shipping: ten bucks'
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_min_amount_is_not_included(): shop = get_default_shop() supplier = get_default_supplier() person = create_random_person() initial_group_count = person.groups.count() sales_ranges = [ ("silver", 0, 50), ("gold", 50, 100), ("diamond", 100, 1000), ("reverse_diamond", 1000, 100) ] for identifier, min, max in sales_ranges: create_sales_range(identifier, shop, min, max) payment = create_fully_paid_order(shop, person, supplier, "sku1", 50) assert _get_total_sales(shop, person) == 50 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool([group for group in person.groups.all() if group.identifier == "gold"]) assert not bool([group for group in person.groups.all() if group.identifier in ["silver", "diamond"]]) payment = create_fully_paid_order(shop, person, supplier, "sku2", 50) assert _get_total_sales(shop, person) == 100 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool([group for group in person.groups.all() if group.identifier == "diamond"]) assert not bool([group for group in person.groups.all() if group.identifier == "reverse_diamond"]) assert not bool([group for group in person.groups.all() if group.identifier in ["silver", "gold"]])
def _get_test_product(): shop = get_default_shop() product = create_product("Just-A-Pricing-Product", shop, default_price=200) CgpPrice.objects.create( product=product, shop=shop, group=get_default_customer_group(), price_value=250) return product
def test_change_shop_price(): product = _get_test_product() shop = get_default_shop() form_field = "s_%d" % shop.id frm = DiscountPricingForm(product=product, empty_permitted=True) form_data = get_form_data(frm, prepared=True) # Price hike time! form_data[form_field] = "120" frm = DiscountPricingForm(product=product, data=form_data, empty_permitted=True) frm.full_clean() frm.save() assert DiscountedProductPrice.objects.get(product=product, shop=shop).price.value == 120 # Never mind actually, same price for all shops form_data[form_field] = "" frm = DiscountPricingForm(product=product, data=form_data, empty_permitted=True) frm.full_clean() frm.save() assert not DiscountedProductPrice.objects.filter(product=product, shop=shop).exists()
def test_address_phase_authorized_user(rf, admin_user): request = apply_request_middleware(rf.get("/"), shop=get_default_shop(), customer=get_person_contact(admin_user)) view_func = AddressesPhase.as_view() resp = view_func(request) assert 'company' not in resp.context_data['form'].form_defs
def test_sales_ranges_basic(): shop = get_default_shop() supplier = get_default_supplier() person = create_random_person() initial_group_count = person.groups.count() sales_ranges = [("silver", 0, 50), ("gold", 50, 100), ("diamond", 100, 1000)] for identifier, min, max in sales_ranges: create_sales_level(identifier, shop, min, max) payment = create_fully_paid_order(shop, person, supplier, "sku1", 10) assert _get_total_sales(shop, person) == 10 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool([ group for group in person.groups.all() if group.identifier == "silver" ]) payment = create_fully_paid_order(shop, person, supplier, "sku2", 50) assert _get_total_sales(shop, person) == 60 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool( [group for group in person.groups.all() if group.identifier == "gold"]) payment = create_fully_paid_order(shop, person, supplier, "sku3", 200) assert _get_total_sales(shop, person) == 260 update_customers_groups(Payment, payment) assert person.groups.count() == (initial_group_count + 1) assert bool([ group for group in person.groups.all() if group.identifier == "diamond" ])
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_sales_ranges_update_after_range_update(): shop = get_default_shop() supplier = get_default_supplier() person = create_random_person() company = create_random_company() create_fully_paid_order(shop, person, supplier, "sku1", 50) create_fully_paid_order(shop, company, supplier, "sku2", 100) assert get_total_sales(shop, person) == 50 assert get_total_sales(shop, company) == 100 sales_range = create_sales_range("gold", shop, 10, 90) assert sales_range.group in person.groups.all() assert sales_range.group not in company.groups.all() sales_range.max_value = None sales_range.save() assert sales_range.group in person.groups.all() assert sales_range.group in company.groups.all() # Make sure customers is actually removed when range changes sales_range.max_value = 60 sales_range.save() assert sales_range.group in person.groups.all() assert sales_range.group not in company.groups.all() # Inactive ranges shouldn't update group members sales_range.min_value = None sales_range.save() assert sales_range.group in person.groups.all() assert sales_range.group not in company.groups.all()
def test_admin_form(rf, admin_user): supplier = get_simple_supplier() shop = get_default_shop() product = create_product("simple-test-product", shop, supplier) request = rf.get("/") request.user = admin_user frm = SimpleSupplierForm(product=product, request=request) # Form contains 1 product even if the product is not stocked assert len(frm.products) == 1 assert not frm.products[0].is_stocked() product.stock_behavior = StockBehavior.STOCKED # Make product stocked product.save() # Now since product is stocked it should be in the form frm = SimpleSupplierForm(product=product, request=request) assert len(frm.products) == 1 # Add stocked children for product child_product = create_product("child-test-product", shop, supplier) child_product.stock_behavior = StockBehavior.STOCKED child_product.save() child_product.link_to_parent(product) # Admin form should now contain only child products for product frm = SimpleSupplierForm(product=product, request=request) assert len(frm.products) == 1 assert frm.products[0] == child_product
def test_source_lines_with_multiple_fixed_costs(): """ Costs with description creates new line always and costs without description is combined into one line. """ translation.activate("en") starting_price_value = 5 sm = get_shipping_method(name="Multiple costs", price=starting_price_value) sm.behavior_components.clear() source = BasketishOrderSource(get_default_shop()) source.shipping_method = sm lines = list(sm.get_lines(source)) assert len(lines) == 1 assert get_total_price_value(lines) == Decimal("0") sm.behavior_components.add(FixedCostBehaviorComponent.objects.create(price_value=10)) lines = list(sm.get_lines(source)) assert len(lines) == 1 assert get_total_price_value(lines) == Decimal("10") sm.behavior_components.add(FixedCostBehaviorComponent.objects.create(price_value=15, description="extra")) lines = list(sm.get_lines(source)) assert len(lines) == 2 assert get_total_price_value(lines) == Decimal("25") sm.behavior_components.add(FixedCostBehaviorComponent.objects.create(price_value=1)) lines = list(sm.get_lines(source)) assert len(lines) == 2 assert get_total_price_value(lines) == Decimal("26")
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 test_change_shop_price(): product = _get_test_product() shop = get_default_shop() group = get_default_customer_group() form_field = "s_%d_g_%d" % (shop.id, group.id) frm = SimplePricingForm(product=product, empty_permitted=True) form_data = get_form_data(frm, prepared=True) # Price hike time! form_data[form_field] = "4000" frm = SimplePricingForm(product=product, data=form_data, empty_permitted=True) frm.full_clean() frm.save() assert SimpleProductPrice.objects.get(product=product, shop=shop, group=group).price == 4000 # Never mind actually, same price for all shops form_data[form_field] = "" frm = SimplePricingForm(product=product, data=form_data, empty_permitted=True) frm.full_clean() frm.save() assert not SimpleProductPrice.objects.filter( product=product, shop=shop, group=group).exists()
def get_frontend_order_state(contact, valid_lines=True): """ Get a dict structure mirroring what the frontend JavaScript would submit. :type contact: Contact|None """ translation.activate("en") shop = get_default_shop() tax = Tax.objects.create(code="test_code", rate=decimal.Decimal("0.20"), name="Default") tax_class = TaxClass.objects.create(identifier="test_tax_class", name="Default") rule = TaxRule.objects.create(tax=tax) rule.tax_classes.add(tax_class) rule.save() product = create_product( sku=printable_gibberish(), supplier=get_default_supplier(), shop=shop ) product.tax_class = tax_class product.save() if valid_lines: lines = [ {"id": "x", "type": "product", "product": {"id": product.id}, "quantity": "32", "baseUnitPrice": 50}, {"id": "y", "type": "other", "sku": "hello", "text": "A greeting", "quantity": 1, "unitPrice": "5.5"}, {"id": "z", "type": "text", "text": "This was an order!", "quantity": 0}, ] else: unshopped_product = create_product(sku=printable_gibberish(), supplier=get_default_supplier()) not_visible_product = create_product( sku=printable_gibberish(), supplier=get_default_supplier(), shop=shop ) not_visible_shop_product = not_visible_product.get_shop_instance(shop) not_visible_shop_product.visible = False not_visible_shop_product.save() lines = [ {"id": "x", "type": "product"}, # no product? {"id": "x", "type": "product", "product": {"id": unshopped_product.id}}, # not in this shop? {"id": "y", "type": "product", "product": {"id": -product.id}}, # invalid product? {"id": "z", "type": "other", "quantity": 1, "unitPrice": "q"}, # what's that price? {"id": "rr", "type": "product", "quantity": 1, "product": {"id": not_visible_product.id}} # not visible ] state = { "customer": {"id": contact.id if contact else None}, "lines": lines, "methods": { "shippingMethod": {"id": get_default_shipping_method().id}, "paymentMethod": {"id": get_default_payment_method().id}, }, "shop": { "selected": { "id": shop.id, "name": shop.name, "currency": shop.currency, "priceIncludeTaxes": shop.prices_include_tax } } } return state
def test_form_populate_initial_data(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() campaign = BasketCampaign(discount_percentage=0.1, shop=shop) campaign.save() # Test that correct initial value is returned for non-many-to-many field product_amount_initial = 10 product_amount_condition = BasketTotalProductAmountCondition(product_count=product_amount_initial) product_amount_condition.save() campaign.conditions.add(product_amount_condition) products_count_initial = 5 for i in range(products_count_initial): create_product(printable_gibberish(), shop=shop, supplier=supplier, default_price="20") products_initial = Product.objects.all()[:products_count_initial] assert len(products_initial) == products_count_initial # Test that correct initial value is returned for many-to-many field products_in_basket_condition = ProductsInBasketCondition.objects.create() products_in_basket_condition.values = products_initial products_in_basket_condition.save() campaign.conditions.add(products_in_basket_condition) assert len(campaign.conditions.all()) == 2 request=apply_request_middleware(rf.get("/"), user=admin_user) form = BasketCampaignForm(request=request, instance=campaign) assert form.fields["basket_product_condition"].initial == product_amount_initial assert set(form.fields["basket_products_condition"].initial) == set([p.pk for p in products_initial])
def test_cross_sell_plugin_type(): """ Test that template helper returns correct number of cross sells when shop contains multiple relation types """ shop = get_default_shop() supplier = get_default_supplier() product = create_product("test-sku", shop=shop, supplier=supplier, stock_behavior=StockBehavior.UNSTOCKED) context = get_jinja_context(product=product) type_counts = ((ProductCrossSellType.RELATED, 1), (ProductCrossSellType.RECOMMENDED, 2), (ProductCrossSellType.BOUGHT_WITH, 3)) # Create cross sell products and relations in different quantities for type, count in type_counts: _create_cross_sell_products(product, shop, supplier, type, count) assert ProductCrossSell.objects.filter(product1=product, type=type).count() == count # Make sure quantities returned by plugin match for type, count in type_counts: assert len( list( product_helpers.get_product_cross_sells( context, product, type, count))) == count
def test_coupon_amount_limit(): coupon = Coupon.objects.create(code="TEST", active=True) get_default_campaign(coupon) contact = create_random_person() shop = get_default_shop() product = create_product("test", shop=shop, supplier=get_default_supplier(), default_price="12") order = create_random_order(customer=contact) for x in range(50): coupon.use(order) assert coupon.usages.count() == 50 coupon.increase_usage_limit_by(5) coupon.save() assert coupon.usage_limit == 55 assert coupon.can_use_code(contact) for x in range(5): coupon.use(order) assert coupon.usages.count() == 55 assert not Coupon.is_usable(coupon.code, order.customer) assert coupon.usages.count() == 55 # no change, limit met