def test_theme_without_default_template_dir(): get_default_shop() with override_current_theme_class(ShuupTestingTheme): c = SmartClient() soup = c.soup(reverse("shuup:index")) assert "Simple base for themes to use" not in soup assert "Welcome to test Shuup!" in soup.find("div", {"class": "page-content"}).text
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_update_injection(): shop = factories.get_default_shop() client = SmartClient() index_url = reverse("shuup:index") page = ensure_gdpr_privacy_policy(shop) shop_gdpr = GDPRSettings.get_for_shop(shop) shop_gdpr.enabled = True shop_gdpr.privacy_policy = page shop_gdpr.save() assert_update(client, index_url, False) # nothing consented in past, should not show user = factories.create_random_user("en") password = "******" user.set_password(password) user.save() client.login(username=user.username, password=password) assert_update(client, index_url, False) # no consent given, should not be visible create_user_consent_for_all_documents(shop, user) assert_update(client, index_url, False) with reversion.create_revision(): page.save() assert not is_documents_consent_in_sync(shop, user) assert_update(client, index_url, True) # consent client.get(reverse("shuup:gdpr_policy_consent", kwargs=dict(page_id=page.pk))) assert is_documents_consent_in_sync(shop, user) assert_update(client, index_url, False)
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_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_basket_line_descriptor(rf): shop = factories.get_default_shop() user = factories.create_random_user() supplier = factories.get_default_supplier() product = factories.create_product("product", shop, supplier, 10) client = SmartClient() response = client.post(path=reverse("shuup:basket"), data={ "command": "add", "product_id": product.pk, "quantity": 1 }) with override_provides("front_line_properties_descriptor", [ "shuup.testing.line_properties_descriptor.TestLinePropertiesDescriptor" ]): soup = client.soup(reverse("shuup:basket")) basket_line_property = soup.find("p", {"class": "basket-line-property"}) assert basket_line_property.find("strong", { "class": "property-name" }).text.strip() == "Type:" assert basket_line_property.find("span", { "class": "property-value" }).text.strip() == "product"
def test_authenticate_form_without_consent_checkboxes(client): activate("en") shop = factories.get_default_shop() user = factories.create_random_user("en") user.email = "*****@*****.**" user.set_password("1234") user.save() consent_text = printable_gibberish() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.skip_consent_on_auth = True gdpr_settings.auth_consent_text = consent_text gdpr_settings.save() # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) redirect_target = "/redirect-success/" client = SmartClient() login_url = reverse("shuup:login") response = client.get(login_url) soup = BeautifulSoup(response.content) login_form = soup.find("form", {"action": "/login/"}) assert len(login_form.findAll("input")) == 4 assert consent_text in login_form.text # user didn't check the privacy policy agreement response = client.post(login_url, data={ "username": user.email, "password": "******", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 302
def test_product_price_range_filter(): shop = factories.get_default_shop() product = factories.get_default_product() category = factories.get_default_category() shop_product = product.get_shop_instance(shop) shop_product.default_price_value = 10 shop_product.categories.add(category) shop_product.save() client = SmartClient() set_configuration(category=category, data={ "filter_products_by_price": True, "filter_products_by_price_range_min": 5, "filter_products_by_price_range_max": 15, "filter_products_by_price_range_size": 5 }) url = reverse('shuup:category', kwargs={ 'pk': category.pk, 'slug': category.slug }) response, soup = client.response_and_soup(url) assert response.status_code == 200 assert soup.find(id="product-%d" % product.id) price_range_select = soup.find(id="id_price_range") price_ranges = price_range_select.find_all("option") assert len(price_ranges) == 4 # filter products with prices above $15 filtered_url = "{}?price_range={}".format(url, price_ranges[-1].attrs["value"]) response, soup = client.response_and_soup(filtered_url) assert response.status_code == 200 assert not soup.find(id="product-%d" % product.id)
def test_shop_remove_available_languages(admin_user): shop = factories.get_default_shop() client = SmartClient() with override_settings(LANGUAGES=[ ("en", "English"), ("fi", "Finnish"), ], LANGUAGE_CODE="en", PARLER_DEFAULT_LANGUAGE_CODE="en"): # there is no language set for the shop, the first one will be used response = client.get(reverse("shuup:index")) assert get_language() == "en" # request js catalog file response = client.get(reverse("shuup:js-catalog")) assert get_language() == "en" # when requesting admin js catalog, the language should be any of the available client.get("shuup_admin:js-catalog") assert get_language() == "en" set_shop_available_languages(shop, ["fi"]) response = client.get(reverse("shuup:index")) assert get_language() == "fi" response = client.get(reverse("shuup:js-catalog")) assert get_language() == "fi" client.get("shuup_admin:js-catalog") assert get_language() == "en"
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_theme_with_default_template_dir(): get_default_shop() with override_current_theme_class(ShuupTestingThemeWithCustomBase): c = SmartClient() soup = c.soup(reverse("shuup:index")) assert "Simple base for themes to use" in soup.find("h1").text assert "Welcome to test Shuup!" in soup.find("h1").text
def test_consent_cookies(client): """ Test that the GDPR consent is generated and saved into a cooki """ shop = factories.get_default_shop() client = SmartClient() index_url = reverse("shuup:index") response = client.get(index_url) # create a GDPR setting for the shop shop_gdpr = GDPRSettings.get_for_shop(shop) shop_gdpr.cookie_banner_content = "my cookie banner content" shop_gdpr.cookie_privacy_excerpt = "my cookie privacyexcerpt" shop_gdpr.enabled = True shop_gdpr.save() # create cookie categories required_cookie_category = GDPRCookieCategory.objects.create( shop=shop, always_active=True, cookies="cookie1,cookir2,_cookie3", name="RequiredCookies", how_is_used="to make the site work") optional_cookie_category = GDPRCookieCategory.objects.create( shop=shop, always_active=False, cookies="_opt1,_opt2,_opt3", name="OptionalCookies", how_is_used="to spy users") # create privacy policy GDPR document privacy_policy = Page.objects.create( shop=shop, title="Privacy policy", url="privacy-policy", page_type=PageType.GDPR_CONSENT_DOCUMENT, content="you just agree", available_from=now()) response = client.get(index_url) assert settings.SHUUP_GDPR_CONSENT_COOKIE_NAME not in response.cookies # send consent response = client.post( reverse("shuup:gdpr_consent"), data={ "cookie_category_{}".format(required_cookie_category.id): "on", "cookie_category_{}".format(optional_cookie_category.id): "on" }) assert settings.SHUUP_GDPR_CONSENT_COOKIE_NAME in response.cookies cookies_data = json.loads( response.cookies[settings.SHUUP_GDPR_CONSENT_COOKIE_NAME].value) assert privacy_policy.id == cookies_data["documents"][0]["id"] assert privacy_policy.url == cookies_data["documents"][0]["url"] for cookie in required_cookie_category.cookies.split(","): assert cookie in cookies_data["cookies"] for cookie in optional_cookie_category.cookies.split(","): assert cookie in cookies_data["cookies"]
def test_extender_renders_main_menu(rf): get_default_shop() with override_provides("front_menu_extender", ["shuup_tests.xtheme.test_extenders:TestExtender"]): c = SmartClient() soup = c.soup(reverse("shuup:index")) link_texts = [a.text for a in soup.findAll("a")] assert "Test Link to Front" in link_texts
def initialize_test(regular_user, person=True): client = SmartClient() get_default_shop() if person: contact = get_person_contact(regular_user) else: contact = get_company_contact(regular_user) client.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) return client, contact
def test_shop_remove_available_languages(admin_user): shop = factories.get_default_shop() client = SmartClient() with override_settings( LANGUAGES=[ ("en", "English"), ("fi", "Finnish"), ], LANGUAGE_CODE="en", PARLER_DEFAULT_LANGUAGE_CODE = "en" ): # there is no language set for the shop, the first one will be used response = client.get(reverse("shuup:index")) assert get_language() == "en" # request js catalog file response = client.get(reverse("shuup:js-catalog")) assert get_language() == "en" # when requesting admin js catalog, the language should be any of the available client.get("shuup_admin:js-catalog") assert get_language() == "en" set_shop_available_languages(shop, ["fi"]) response = client.get(reverse("shuup:index")) assert get_language() == "fi" response = client.get(reverse("shuup:js-catalog")) assert get_language() == "fi" client.get("shuup_admin:js-catalog") assert get_language() == "en"
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_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 test_notify_on_company_created(regular_user, allow_company_registration): if "shuup.front.apps.customer_information" not in settings.INSTALLED_APPS: pytest.skip("shuup.front.apps.customer_information required in installed apps") if "shuup.notify" not in settings.INSTALLED_APPS: pytest.skip("shuup.notify required in installed apps") configuration.set(None, "allow_company_registration", allow_company_registration) step = Step( cond_op=StepConditionOperator.NONE, actions=[ AddNotification( { "message": {"constant": "It Works. {{ customer_email }}"}, "message_identifier": {"constant": "company_created"}, } ) ], next=StepNext.STOP, ) script = Script( event_identifier=CompanyAccountCreated.identifier, name="Test Script", enabled=True, shop=get_default_shop() ) script.set_steps([step]) script.save() assert not Notification.objects.filter(identifier="company_created").exists() assert get_person_contact(regular_user) assert not get_company_contact(regular_user) client = SmartClient() client.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) company_edit_url = reverse("shuup:company_edit") if allow_company_registration: client.soup(company_edit_url) data = _default_company_data() data.update(_default_address_data("billing")) data.update(_default_address_data("shipping")) response, soup = client.response_and_soup(company_edit_url, data, "post") assert response.status_code == 302 assert get_company_contact(regular_user) assert Notification.objects.filter(identifier="company_created").count() == 1 notification = Notification.objects.filter(identifier="company_created").first() assert notification assert data["contact-email"] in notification.message # New save should not add new notifications response, soup = client.response_and_soup(company_edit_url, data, "post") assert response.status_code == 302 assert Notification.objects.filter(identifier="company_created").count() == 1 script.delete() else: response = client.get(company_edit_url) assert reverse("shuup:customer_edit") in response.url assert Notification.objects.filter(identifier="company_created").count() == 0
def test_consent_cookies(): """ Test that the GDPR consent is generated and saved into a cooki """ for code, lang in settings.LANGUAGES: activate(code) shop = factories.get_default_shop() client = SmartClient() index_url = reverse("shuup:index") response = client.get(index_url) # create a GDPR setting for the shop shop_gdpr = GDPRSettings.get_for_shop(shop) shop_gdpr.cookie_banner_content = "my cookie banner content" shop_gdpr.cookie_privacy_excerpt = "my cookie privacyexcerpt" shop_gdpr.enabled = True shop_gdpr.save() # create cookie categories required_cookie_category = GDPRCookieCategory.objects.create( shop=shop, always_active=True, cookies="cookie1,cookir2,_cookie3", name="RequiredCookies", how_is_used="to make the site work" ) optional_cookie_category = GDPRCookieCategory.objects.create( shop=shop, always_active=False, cookies="_opt1,_opt2,_opt3", name="OptionalCookies", how_is_used="to spy users" ) # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) response = client.get(index_url) assert settings.SHUUP_GDPR_CONSENT_COOKIE_NAME not in response.cookies # send consent response = client.post(reverse("shuup:gdpr_consent"), data={ "cookie_category_{}".format(required_cookie_category.id): "on", "cookie_category_{}".format(optional_cookie_category.id): "on" }) assert settings.SHUUP_GDPR_CONSENT_COOKIE_NAME in response.cookies cookies_data = json.loads(response.cookies[settings.SHUUP_GDPR_CONSENT_COOKIE_NAME].value) assert privacy_policy.id == cookies_data["documents"][0]["id"] assert privacy_policy.url == cookies_data["documents"][0]["url"] for cookie in required_cookie_category.cookies.split(","): assert cookie in cookies_data["cookies"] for cookie in optional_cookie_category.cookies.split(","): assert cookie in cookies_data["cookies"]
def test_admin_set_shop_language(admin_user): original_language = get_language() shop = factories.get_default_shop() client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") with override_settings(LANGUAGES=[("it", "Italian"), ("fr", "French"), ("fi", "Finnish"), ("pt-br", "Portuguese (Brazil)")], LANGUAGE_CODE="it", PARLER_DEFAULT_LANGUAGE_CODE="it"): assert get_shop_available_languages(shop) == [] edit_url = reverse("shuup_admin:shop.edit", kwargs=dict(pk=shop.id)) payload = { "translation_config-available_languages": ["pt-br", "fi"], "base-public_name__it": shop.public_name, "base-name__it": shop.name, "base-status": "1", "base-currency": shop.currency, "product_list_facets-filter_products_by_category_ordering": "1", "product_list_facets-filter_products_by_price_ordering": "1", "product_list_facets-limit_product_list_page_size_ordering": "1", "product_list_facets-sort_products_by_price_ordering": "1", "product_list_facets-sort_products_by_name_ordering": "1", "product_list_facets-sort_products_by_ascending_created_date_ordering": "1", "product_list_facets-sort_products_by_date_created_ordering": "1", "product_list_facets-filter_products_by_manufacturer_ordering": "1", "product_list_facets-filter_products_by_variation_value_ordering": "1", "order_configuration-order_reference_number_length": "20", "order_configuration-order_reference_number_prefix": "10" } response = client.post(edit_url, data=payload) assert response.status_code == 302 assert get_shop_available_languages(shop) == ["pt-br", "fi"] activate(original_language)
def test_basic_order_flow_not_registered(with_company): 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) c = SmartClient() 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, with_company=with_company) 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["accept_terms"] = True 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["en"][ "subject"], "Subject doesn't match" assert latest_mail.body == template_data["en"][ "body"], "Body doesn't match"
def test_theme_with_default_template_dir(): with override_settings(CACHES={ 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'test_configuration_cache', } }): cache.init_cache() get_default_shop() with override_current_theme_class(ShuupTestingThemeWithCustomBase, get_default_shop()): c = SmartClient() soup = c.soup(reverse("shuup:index")) assert "Simple base for themes to use" in soup.find("h1").text assert "Welcome to test Shuup!" in soup.find("h1").text
def test_register_form(client): activate("en") shop = factories.get_default_shop() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.save() # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) redirect_target = "/index/" client = SmartClient() # user didn't checked the privacy policy agreement response = client.post( reverse("shuup:registration_register"), data={ "username": "******", "email": "*****@*****.**", "password1": "1234", "password2": "1234", REDIRECT_FIELD_NAME: redirect_target, }, ) assert response.status_code == 200 assert "You must accept this in order to register." in response.content.decode( "utf-8") response = client.post( reverse("shuup:registration_register"), data={ "username": "******", "email": "*****@*****.**", "password1": "1234", "password2": "1234", "accept_%d" % privacy_policy.id: "on", REDIRECT_FIELD_NAME: redirect_target, }, ) assert response.status_code == 302 assert response.get("location") assert response.get("location").endswith(redirect_target) user = User.objects.first() assert is_documents_consent_in_sync(shop, user) ensure_gdpr_privacy_policy(shop, force_update=True) assert not is_documents_consent_in_sync(shop, user)
def test_company_edit_form_links_company(regular_user, allow_company_registration): get_default_shop() configuration.set(None, "allow_company_registration", allow_company_registration) person = get_person_contact(regular_user) assert not get_company_contact(regular_user) client = SmartClient() client.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) data = default_company_data() data.update(default_address_data("billing")) data.update(default_address_data("shipping")) company_edit_url = reverse("shuup:company_edit") if allow_company_registration: soup = client.soup(company_edit_url) response, soup = client.response_and_soup(company_edit_url, data, "post") assert response.status_code == 302 assert get_company_contact(regular_user) else: response = client.get(company_edit_url) assert reverse("shuup:customer_edit") in response.url response = client.post(company_edit_url, data) assert reverse("shuup:customer_edit") in response.url
def test_new_shop_product_suppliers_init(rf, admin_user, multiple_suppliers): with override_settings(SHUUP_ENABLE_MULTIPLE_SUPPLIERS=multiple_suppliers): shop = get_default_shop() supplier = get_default_supplier() tax_class = get_default_tax_class() product_type = get_default_product_type() sales_unit = get_default_sales_unit() assert ShopProduct.objects.count() == 0 client = SmartClient() client.login(username="******", password="******") soup = client.soup(reverse("shuup_admin:shop_product.new")) supplier_select = soup.find("select", attrs={"name": "shop%s-suppliers" % shop.id}) assert len(supplier_select.find_all("option")) == (0 if multiple_suppliers else 1)
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_shop_available_languages(admin_user): original_language = get_language() shop = factories.get_default_shop() client = SmartClient() with override_settings( LANGUAGES=[ ("it", "Italian"), ("fr", "French"), ("fi", "Finnish"), ("pt", "Portuguese") ], LANGUAGE_CODE="it", PARLER_DEFAULT_LANGUAGE_CODE = "it" ): # there is no language set for the shop, the first one will be used response = client.get(reverse("shuup:index")) assert get_language() == "it" # set an invalid language code with pytest.raises(ValueError): set_shop_available_languages(shop, ["xpto"]) # limit the langauges for the shop to "fi" and "pt" set_shop_available_languages(shop, ["fi", "pt"]) # the middleware will automatically set the language to "fi" as that is the first one available for the shop response = client.get(reverse("shuup:index")) assert get_language() == "fi" # the same won't happen for any other url - the middleware will only affect front urls client.get("shuup_admin:index") assert get_language() == "it" # test againt front again client.get(reverse("shuup:index")) assert get_language() == "fi" # again for admin client.get("shuup_admin:index") assert get_language() == "it" # remote all available languages set_shop_available_languages(shop, []) # this should fallback to settings.LAGUAGE_CODE response = client.get(reverse("shuup:index")) assert get_language() == "it" activate(original_language)
def test_customer_edit_redirects_to_login_if_not_logged_in(): get_default_shop() # Front middleware needs a Shop to exists urls = ["shuup:customer_edit", "shuup: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_authenticate_form(client): activate("en") shop = factories.get_default_shop() user = factories.create_random_user("en") user.email = "*****@*****.**" user.set_password("1234") user.save() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.save() # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) redirect_target = "/redirect-success/" client = SmartClient() login_url = reverse("shuup:login") response = client.get(login_url) soup = BeautifulSoup(response.content) login_form = soup.find("form", {"action": "/login/"}) assert len(login_form.findAll("input")) == 5 # 4 + privacy policy checkbox # user didn't check the privacy policy agreement response = client.post(reverse("shuup:login"), data={ "username": user.email, "password": "******", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 200 assert "You must accept this in order to authenticate." in response.content.decode( "utf-8") response = client.post( reverse("shuup:login"), data={ "username": user.email, "password": "******", "accept_%d" % privacy_policy.id: "on", REDIRECT_FIELD_NAME: redirect_target, }, ) assert response.status_code == 302 assert response.get("location") assert response.get("location").endswith(redirect_target)
def test_user_change_password(regular_user, password_value, new_password_2, expected): get_default_shop() assert check_password(REGULAR_USER_PASSWORD, regular_user.password) client = SmartClient() client.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) change_password_url = reverse("shuup:change_password") new_password = "******" data = {"old_password": password_value, "new_password1": new_password, "new_password2": new_password_2} response, soup = client.response_and_soup(change_password_url, data, "post") user = get_user_model().objects.get(pk=regular_user.pk) assert regular_user == user assert check_password(REGULAR_USER_PASSWORD, user.password) != expected assert check_password(new_password, user.password) == expected
def test_notify_on_company_created(regular_user, allow_company_registration): if "shuup.front.apps.customer_information" not in settings.INSTALLED_APPS: pytest.skip("shuup.front.apps.customer_information required in installed apps") if "shuup.notify" not in settings.INSTALLED_APPS: pytest.skip("shuup.notify required in installed apps") configuration.set(None, "allow_company_registration", allow_company_registration) step = Step( cond_op=StepConditionOperator.NONE, actions=[ AddNotification({ "message": {"constant": "It Works. {{ customer_email }}"}, "message_identifier": {"constant": "company_created"}, }) ], next=StepNext.STOP ) script = Script( event_identifier=CompanyAccountCreated.identifier, name="Test Script", enabled=True, shop=get_default_shop()) script.set_steps([step]) script.save() assert not Notification.objects.filter(identifier="company_created").exists() assert get_person_contact(regular_user) assert not get_company_contact(regular_user) client = SmartClient() client.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) company_edit_url = reverse("shuup:company_edit") if allow_company_registration: client.soup(company_edit_url) data = _default_company_data() data.update(_default_address_data("billing")) data.update(_default_address_data("shipping")) response, soup = client.response_and_soup(company_edit_url, data, "post") assert response.status_code == 302 assert get_company_contact(regular_user) assert Notification.objects.filter(identifier="company_created").count() == 1 notification = Notification.objects.filter(identifier="company_created").first() assert notification assert data["contact-email"] in notification.message # New save should not add new notifications response, soup = client.response_and_soup(company_edit_url, data, "post") assert response.status_code == 302 assert Notification.objects.filter(identifier="company_created").count() == 1 script.delete() else: response = client.get(company_edit_url) assert reverse("shuup:customer_edit") in response.url assert Notification.objects.filter(identifier="company_created").count() == 0
def test_custom_file_transformer_import(admin_user): shop = get_default_shop() shop.staff_members.add(admin_user) get_default_tax_class() get_default_product_type() get_default_sales_unit() client = SmartClient() client.login(username="******", password="******") import_path = reverse("shuup_admin:importer.import.new") process_path = reverse("shuup_admin:importer.import_process") client = SmartClient() client.login(username="******", password="******") csv_content = str.encode("sku;name\n123;Teste") data = { "importer": "product_importer", "shop": shop.pk, "language": "en", "file": SimpleUploadedFile("file.csv", csv_content, content_type="text/csv"), } response = client.post(import_path, data=data) assert response.status_code == 302 with mock.patch.object(ProductImporter, "custom_file_transformer", True): assert ProductImporter.custom_file_transformer is True query_string = urlparse(response["location"]).query process_submit_path = "%s?%s" % (process_path, query_string) query = parse_qs(query_string) data = { "importer": "product_importer", "shop": shop.pk, "language": "en", "n": query.get("n"), } response = client.post(process_submit_path, data=data) assert response.status_code == 302 assert "The import was queued!" in list( response.wsgi_request._messages)[0].message task_execution = BackgroundTaskExecution.objects.last() assert task_execution.status == BackgroundTaskExecutionStatus.ERROR assert "Error! Not implemented: `DataImporter` -> `transform_file()`." in task_execution.error_log
def test_resource_injection(client): """ Test that the GDPR warning is injected into the front template when enabled """ activate("en") shop = factories.get_default_shop() client = SmartClient() index_url = reverse("shuup:index") response = client.get(index_url) assert "gdpr-consent-warn-bar" not in response.content.decode("utf-8") # create a GDPR setting for the shop shop_gdpr = GDPRSettings.get_for_shop(shop) shop_gdpr.cookie_banner_content = "my cookie banner content" shop_gdpr.cookie_privacy_excerpt = " my cookie privacyexcerpt" shop_gdpr.enabled = True shop_gdpr.save() # the contents should be injected in the html response = client.get(index_url) response_content = response.content.decode("utf-8") assert "gdpr-consent-warn-bar" in response_content assert shop_gdpr.cookie_banner_content in response_content assert shop_gdpr.cookie_privacy_excerpt in response_content # create cookie categories cookie_category = GDPRCookieCategory.objects.create( shop=shop, always_active=True, cookies="cookie1,cookie2,_cookie3", name="RequiredCookies", how_is_used="to make the site work" ) response = client.get(index_url) response_content = response.content.decode("utf-8") assert "gdpr-consent-warn-bar" in response_content assert cookie_category.cookies in response_content assert cookie_category.name in response_content assert cookie_category.how_is_used in response_content # make sure no other shop has this with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=True): shop2 = factories.get_shop(identifier="shop2", status=ShopStatus.DISABLED, domain="shop2") response = client.get(index_url, HTTP_HOST=shop2.domain) response_content = response.content.decode("utf-8") assert "gdpr-consent-warn-bar" not in response_content
def test_task_type_admin(admin_user): activate("en") shop = factories.get_default_shop() admin_user.set_password(ADMIN_PWD) admin_user.save() admin_contact = get_person_contact(admin_user) admin_contact.shops.add(shop) client = SmartClient() client.login(username=admin_user.username, password=ADMIN_PWD) # Create new task type new_task_type_url = reverse("shuup_admin:task_type.new") assert TaskType.objects.count() == 0 # get the form fields soup = client.soup(new_task_type_url) payload = extract_form_fields(soup) payload.update({ "name__en": "My Task Type" }) response = client.post(new_task_type_url, payload) assert response.status_code == 302 assert TaskType.objects.count() == 1 task_type = TaskType.objects.first() # List task types list_task_type_url = reverse("shuup_admin:task_type.list") list_data = { "jq": json.dumps({ "sort": None, "perPage": 20, "page": 1, "filters": {} }) } response = client.get(list_task_type_url, data=list_data) assert task_type.name in response.content.decode("utf-8") # Edit task type edit_task_type_url = reverse("shuup_admin:task_type.edit", kwargs=dict(pk=task_type.pk)) soup = client.soup(edit_task_type_url) payload = extract_form_fields(soup) payload.update({ "name__en": "My Task Type Edited" }) response = client.post(edit_task_type_url, payload) assert response.status_code == 302
def test_register_form(client): activate("en") shop = factories.get_default_shop() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.save() # create privacy policy GDPR document privacy_policy = Page.objects.create( shop=shop, title="Privacy policy", url="privacy-policy", page_type=PageType.GDPR_CONSENT_DOCUMENT, content="you just agree", available_from=now()) redirect_target = "/index/" client = SmartClient() # user didn't checked the privacy policy agreement response = client.post(reverse("shuup:registration_register"), data={ "username": "******", "email": "*****@*****.**", "password1": "1234", "password2": "1234", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 200 assert "You must accept to this to register" in response.content.decode( "utf-8") response = client.post(reverse("shuup:registration_register"), data={ "username": "******", "email": "*****@*****.**", "password1": "1234", "password2": "1234", "accept_%d" % privacy_policy.id: "on", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 302 assert response.get("location") assert response.get("location").endswith(redirect_target)
def test_boleto_not_exists(): initialize() view_boleto_path = reverse("shuup:view_boleto", kwargs={ "order_pk": 123, "order_key": "32131" }) response = SmartClient().get(view_boleto_path) assert response.status_code == 500
def test_company_edit_form_links_company(regular_user, rf): get_default_shop() person = get_person_contact(regular_user) assert not get_company_contact(regular_user) client = SmartClient() client.login(username=REGULAR_USER_USERNAME, password=REGULAR_USER_PASSWORD) company_edit_url = reverse("shuup:company_edit") soup = client.soup(company_edit_url) data = default_company_data() data.update(default_address_data("billing")) data.update(default_address_data("shipping")) response, soup = client.response_and_soup(company_edit_url, data, "post") assert response.status_code == 302 assert get_company_contact(regular_user)
def test_download_examples(rf, admin_user): shop = get_default_shop() import_url = reverse("shuup_admin:importer.import") shop.staff_members.add(admin_user) client = SmartClient() client.login(username="******", password="******") # test downloading all default importers from shuup.importer.utils import get_importer, get_importer_choices assert len(get_importer_choices()) for importer, name in get_importer_choices(): importer_cls = get_importer(importer) if importer_cls.has_example_file(): import_response = client.get("{}?importer={}".format(import_url, importer_cls.identifier)) assert import_response.status_code == 200 assert "This importer provides example files" in import_response.content.decode("utf-8") for example_file in importer_cls.example_files: assert example_file.file_name in import_response.content.decode("utf-8") # download file download_url = "{}?importer={}&file_name={}".format( reverse("shuup_admin:importer.download_example"), importer_cls.identifier, example_file.file_name ) response = client.get(download_url) if importer_cls.identifier == "dummy_file_importer": assert response.status_code == 404 else: assert response.status_code == 200 assert response._headers["content-type"] == ("Content-Type", str(example_file.content_type)) assert response._headers["content-disposition"] == ("Content-Disposition", 'attachment; filename=%s' % example_file.file_name) if example_file.template_name: from django.template.loader import get_template template_file = get_template(example_file.template_name).template.filename assert open(template_file, "r").read().strip() == response.content.decode("utf-8").strip() else: assert response.content
def test_product_subscription_options(): shop = factories.get_default_shop() user = factories.create_random_user() supplier = factories.get_default_supplier() product = factories.create_product("product", shop, supplier, 10) client = SmartClient() with override_provides( "product_subscription_option_provider", [ "shuup.testing.subscription_option_provider.TestSubscriptionOptionProvider" ], ): response = client.soup( reverse("shuup:product", kwargs=dict(pk=product.pk, slug=product.slug))) purchase_options = response.find( "ul", {"class": "product-purchase-options-list-group"}) # there is an option for one-time purchase one_time_purchase = purchase_options.find_all( "li", {"class": "list-group-item"})[0] assert one_time_purchase.find("input", { "name": "purchase-option", "value": "one-time" }) # there is an option for subscription purchase subscription = purchase_options.find_all( "li", {"class": "list-group-item"})[1] assert subscription.find("input", { "name": "purchase-option", "value": "subscription" }) # the subscription options should be yr and mo, according to the TestSubscriptionOptionProvider assert subscription.find_all("input", { "name": "subscription-option", "value": "mo" }) assert subscription.find_all("input", { "name": "subscription-option", "value": "yr" })
def test_register_form(client): activate("en") shop = factories.get_default_shop() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.save() # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) redirect_target = "/index/" client = SmartClient() # user didn't checked the privacy policy agreement response = client.post(reverse("shuup:registration_register"), data={ "username": "******", "email": "*****@*****.**", "password1": "1234", "password2": "1234", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 200 assert "You must accept to this to register." in response.content.decode("utf-8") response = client.post(reverse("shuup:registration_register"), data={ "username": "******", "email": "*****@*****.**", "password1": "1234", "password2": "1234", "accept_%d" % privacy_policy.id: "on", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 302 assert response.get("location") assert response.get("location").endswith(redirect_target) user = User.objects.first() assert is_documents_consent_in_sync(shop, user) ensure_gdpr_privacy_policy(shop, force_update=True) assert not is_documents_consent_in_sync(shop, user)
def test_admin_set_shop_language(admin_user): original_language = get_language() shop = factories.get_default_shop() client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") with override_settings( LANGUAGES=[ ("it", "Italian"), ("fr", "French"), ("fi", "Finnish"), ("pt-br", "Portuguese (Brazil)") ], LANGUAGE_CODE="it", PARLER_DEFAULT_LANGUAGE_CODE = "it" ): assert get_shop_available_languages(shop) == [] edit_url = reverse("shuup_admin:shop.edit", kwargs=dict(pk=shop.id)) payload = { "translation_config-available_languages": ["pt-br", "fi"], "base-public_name__it": shop.public_name, "base-name__it": shop.name, "base-status": "1", "base-currency": shop.currency, "product_list_facets-filter_products_by_category_ordering": "1", "product_list_facets-filter_products_by_price_ordering": "1", "product_list_facets-limit_product_list_page_size_ordering": "1", "product_list_facets-sort_products_by_price_ordering": "1", "product_list_facets-sort_products_by_name_ordering": "1", "product_list_facets-sort_products_by_ascending_created_date_ordering": "1", "product_list_facets-sort_products_by_date_created_ordering": "1", "product_list_facets-filter_products_by_manufacturer_ordering": "1", "product_list_facets-filter_products_by_variation_value_ordering": "1", "order_configuration-order_reference_number_length": "20", "order_configuration-order_reference_number_prefix": "10" } response = client.post(edit_url, data=payload) assert response.status_code == 302 assert get_shop_available_languages(shop) == ["pt-br", "fi"] activate(original_language)
def test_theme_without_default_template_dir(): with override_settings( CACHES={ "default": { "BACKEND": "django.core.cache.backends.locmem.LocMemCache", "LOCATION": "test_configuration_cache", } }): cache.init_cache() with override_current_theme_class(ShuupTestingTheme, get_default_shop()): c = SmartClient() soup = c.soup(reverse("shuup:index")) assert "Simple base for themes to use" not in soup assert "Welcome to test Shuup!" in soup.find( "div", { "class": "page-content" }).text
def test_import_error(admin_user): shop = get_default_shop() shop.staff_members.add(admin_user) get_default_tax_class() get_default_product_type() get_default_sales_unit() client = SmartClient() client.login(username="******", password="******") import_path = reverse("shuup_admin:importer.import") process_path = reverse("shuup_admin:importer.import_process") client = SmartClient() client.login(username="******", password="******") csv_content = str.encode("sku;name\n123;Teste") data = { "importer": "product_importer", "shop": shop.pk, "language": "en", "file": SimpleUploadedFile("file.csv", csv_content, content_type="text/csv") } response = client.post(import_path, data=data) assert response.status_code == 302 query_string = urlparse(response["location"]).query query = parse_qs(query_string) data = { "importer": "product_importer", "shop": shop.pk, "language": "en", "n": query.get("n"), } data = {} process_submit_path = "%s?%s" % (process_path, query_string) response = client.post(process_submit_path, data=data) assert response.status_code == 302 assert "Failed to import the file." == list( response.wsgi_request._messages)[0].message
def test_gdpr_admin_download_data(client, admin_user): """ Test that admin user can download customer data """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") product = factories.create_product("p1", shop, factories.get_default_supplier()) [factories.create_random_order(customer, [product]) for order in range(3)] client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_download_url = reverse("shuup_admin:gdpr.download_data", kwargs=dict(pk=customer.pk)) response = client.post(admin_download_url) assert response.status_code == 200 assert response._headers["content-disposition"][0] == "Content-Disposition" assert response._headers["content-disposition"][1].startswith("attachment; filename=user_data_")
def test_gdpr_admin_settings(client, admin_user): """ Test that admin user can enable GDPR and add cookie categories """ activate("en") shop = factories.get_default_shop() client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_settings_url = reverse("shuup_admin:gdpr.settings") assert not GDPRSettings.objects.exists() response = client.soup(admin_settings_url) assert GDPRSettings.objects.exists() s = GDPRSettings.objects.first() assert s.cookie_banner_content == settings.SHUUP_GDPR_DEFAULT_BANNER_STRING assert s.cookie_privacy_excerpt == settings.SHUUP_GDPR_DEFAULT_EXCERPT_STRING assert GDPRCookieCategory.objects.count() == 0 page = Page.objects.create(shop=shop, available_from=now()) page.title = "test" page.save() # create the settings with only basic options payload = extract_form_fields(response) payload.pop("base-consent_pages") payload.update({ "base-enabled": True, "base-privacy_policy_page": page.pk, "base-cookie_banner_content__en": "Banner content", "base-cookie_privacy_excerpt__en": "Cookie excerpt", "cookie_categories-0-id": "", "cookie_categories-0-always_active": 1, "cookie_categories-0-name__en": "required", "cookie_categories-0-how_is_used__en": "to work", "cookie_categories-0-cookies": "sessionid", }) response = client.post(admin_settings_url, data=payload) assert response.status_code == 302 assert GDPRCookieCategory.objects.count() == 1 # add one more cookie category payload.update({ "cookie_categories-1-id": "", "cookie_categories-1-always_active": 1, "cookie_categories-1-name__en": "Maybe", "cookie_categories-1-how_is_used__en": "to spy", "cookie_categories-1-cookies": "_ga", }) client.post(admin_settings_url, data=payload) assert GDPRCookieCategory.objects.count() == 2
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_page_layout(): if "shuup.xtheme" not in settings.INSTALLED_APPS: pytest.skip("Need shuup.xtheme in INSTALLED_APPS") shop = factories.get_default_shop() theme = get_current_theme(shop) view_config = ViewConfig(theme=theme, shop=shop, view_name="PageView", draft=True) page1_content = printable_gibberish() page1 = create_page(available_from=datetime.date(1917, 12, 6), content=page1_content, shop=shop, url="test1") page2_content = printable_gibberish() page2 = create_page(available_from=datetime.date(1917, 12, 6), content=page2_content, shop=shop, url="test2") placeholder_name = "cms_page" context = {"page": page1} layout = view_config.get_placeholder_layout(PageLayout, placeholder_name, context=context) assert isinstance(layout, PageLayout) assert layout.get_help_text({}) == "" # Invalid context for help text assert page1.title in layout.get_help_text(context) # Make sure layout is empty serialized = layout.serialize() assert len(serialized["rows"]) == 0 assert serialized["name"] == placeholder_name # Add custom plugin to page layout.begin_column({"md": 8}) plugin_text = printable_gibberish() layout.add_plugin("text", {"text": plugin_text}) view_config.save_placeholder_layout(get_layout_data_key(placeholder_name, layout, context), layout) view_config.publish() c = SmartClient() soup = c.soup(reverse("shuup:cms_page", kwargs={"url": page1.url})) page_content = soup.find("div", {"class": "page-content"}) assert page1_content in page_content.text assert plugin_text in page_content.text c = SmartClient() soup = c.soup(reverse("shuup:cms_page", kwargs={"url": page2.url})) page_content = soup.find("div", {"class": "page-content"}) assert page2_content in page_content.text assert plugin_text not in page_content.text
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_product_detail_view(): vc = _get_basic_view_config(view_name="ProductDetailView") product = factories.create_product("test", shop=factories.get_default_shop(), name="Test product name") product2 = factories.create_product("test2", shop=factories.get_default_shop(), name="Test product name 2") placeholder_name = "product_extra_1" context = {"product": product} layout = vc.get_placeholder_layout(ProductLayout, placeholder_name, context=context) plugin_text = printable_gibberish() _add_plugin_and_test_save(vc, layout, placeholder_name, context, plugin_text) # Also let's confirm that the plugin visibility works with smart client c = SmartClient() soup = c.soup(reverse("shuup:product", kwargs={"pk": product.id, "slug": product.slug})) product_details = soup.find("div", {"class": "product-basic-details"}) assert plugin_text in product_details.text c = SmartClient() soup = c.soup(reverse("shuup:product", kwargs={"pk": product2.id, "slug": product2.slug})) product_details = soup.find("div", {"class": "product-basic-details"}) assert plugin_text not in product_details.text
def test_staff_authentication(): shop = factories.get_shop(True, "USD", enabled=True) staff_user = factories.create_random_user(is_staff=True) staff_user.set_password("randpw") staff_user.save() staff_user.groups = [factories.get_default_permission_group()] shop.staff_members.add(staff_user) assert staff_user in [staff for staff in shop.staff_members.all()] assert shop.status == ShopStatus.ENABLED client = SmartClient() url = reverse("shuup_admin:dashboard") client.login(username=staff_user.username, password="******") response, soup = client.response_and_soup(url) assert response.status_code == 200 shop.status = ShopStatus.DISABLED shop.save() response, soup = client.response_and_soup(url) assert response.status_code == 400 assert "There is no active shop available" in soup.text
def test_invalid_files(rf, admin_user): lang = "en" import_mode = ImportMode.CREATE_UPDATE sku = "123" name = "test" import_path = reverse("shuup_admin:importer.import") process_path = reverse("shuup_admin:importer.import_process") tax_class = get_default_tax_class() product_type = get_default_product_type() get_default_sales_unit() activate("en") shop = get_default_shop() shop.staff_members.add(admin_user) client = SmartClient() client.login(username="******", password="******") csv_content = str.encode("sku;name\n%s;%s" % (sku, name)) # show import view data = { "importer": "product_importer", "shop": shop.pk, "language": lang, "file": SimpleUploadedFile("file.csv", csv_content, content_type="text/csv") } response = client.post(import_path, data=data) assert response.status_code == 302 query_string = urlparse(response["location"]).query query = parse_qs(query_string) data = { # data with missing `n` "importer": "product_importer", "shop": shop.pk, "language": lang, } response, soup = client.response_and_soup(process_path, data=data) assert response.status_code == 400 assert "File missing." in str(soup)
def test_new_user_information_edit(): client = SmartClient() get_default_shop() # create new user user_password = "******" user = get_user_model().objects.create_user( username="******", email="*****@*****.**", password=user_password, first_name="Niilo", last_name="Nyyppä", ) client.login(username=user.username, password=user_password) # make sure all information matches in form customer_edit_url = reverse("shuup:customer_edit") soup = client.soup(customer_edit_url) assert soup.find(attrs={"name": "contact-email"})["value"] == user.email assert soup.find(attrs={"name": "contact-first_name"})["value"] == user.first_name assert soup.find(attrs={"name": "contact-last_name"})["value"] == user.last_name # Test POSTing form = extract_form_fields(soup) new_email = "*****@*****.**" form["contact-email"] = new_email form["contact-country"] = "FI" for prefix in ("billing", "shipping"): form["%s-city" % prefix] = "test-city" form["%s-email" % prefix] = new_email form["%s-street" % prefix] = "test-street" form["%s-country" % prefix] = "FI" response, soup = client.response_and_soup(customer_edit_url, form, "post") assert response.status_code == 302 assert get_user_model().objects.get(pk=user.pk).email == new_email
def test_gdpr_admin_anonymize(client, admin_user): """ Test that admin user can anonymize contact """ activate("en") factories.get_default_shop() person = factories.create_random_person("en") person.user = factories.create_random_user("en") person.save() client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_anonymize_url = reverse("shuup_admin:gdpr.anonymize", kwargs=dict(pk=person.pk)) response = client.post(admin_anonymize_url) assert response.status_code == 302 assert response.url.endswith(reverse("shuup_admin:contact.detail", kwargs=dict(pk=person.pk))) anonymized_person = PersonContact.objects.get(id=person.id) assert anonymized_person.name != person.name assert anonymized_person.user.username != person.user.username