def test_method_edit_save(rf, admin_user, view, model, get_object, service_provider_attr): """ To make things little bit more simple let's use only english as an language. """ with override_settings(LANGUAGES=[("en", "en")]): object = get_object() object.choice_identifier = "" object.save() assert object.choice_identifier == "" view = view.as_view() service_provider_attr_field = "base-%s" % service_provider_attr data = { "base-name__en": object.name, "base-shop": object.shop.id, "base-tax_class": object.tax_class.id, "base-enabled": True, service_provider_attr_field: getattr(object, service_provider_attr).pk, "base-choice_identifier": "manual" } methods_before = model.objects.count() # Behavior components is tested at shuup.tests.admin.test_service_behavior_components with override_provides("service_behavior_component_form", []): with override_provides("service_behavior_component_form_part", []): request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request, pk=object.pk) if hasattr(response, "render"): response.render() assert response.status_code in [200, 302] assert model.objects.count() == methods_before assert model.objects.get(pk=object.pk).choice_identifier == "manual"
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.discount_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", ["shuup.campaigns.admin_module.forms:BasketTotalProductAmountConditionForm"]): with override_provides( "campaign_basket_discount_effect_form", ["shuup.campaigns.admin_module.forms:BasketDiscountAmountForm"]): with override_provides("campaign_basket_line_effect_form", []): 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.discount_effects.count() == 1
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("campaign_product_discount_effect_form", []): 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_view_custom_mass_actions(rf, admin_user): factories.get_default_shop() request = apply_request_middleware(rf.get("/", {"jq": json.dumps({"perPage": 100, "page": 1})}), user=admin_user) list_view_func = ManufacturerListView.as_view() # no mass actions response = list_view_func(request) data = json.loads(response.content.decode("utf-8")) assert not data["massActions"] # test with specific key with override_provides("manufacturer_list_mass_actions_provider", [ "shuup.testing.modules.mocker.mass_actions:DummyMassActionProvider" ]): response = list_view_func(request) data = json.loads(response.content.decode("utf-8")) identifiers = [action["key"] for action in data["massActions"]] assert "dummy_mass_action_1" in identifiers assert "dummy_mass_action_2" in identifiers list_view_func = SalesUnitListView.as_view() # test with global with override_provides("admin_mass_actions_provider", [ "shuup.testing.modules.mocker.mass_actions:DummyMassActionProvider" ]): response = list_view_func(request) data = json.loads(response.content.decode("utf-8")) identifiers = [action["key"] for action in data["massActions"]] assert "dummy_mass_action_1" in identifiers assert "dummy_mass_action_2" in identifiers
def test_custom_view_toolbar_buttons(rf, admin_user): factories.get_default_shop() request = apply_request_middleware(rf.get("/"), user=admin_user) list_view_func = ContactGroupPriceDisplayListView.as_view() edit_view_func = ContactGroupPriceDisplayEditView.as_view() with override_provides("contact_group_price_list_toolbar_provider", [ "shuup.testing.modules.mocker.toolbar:ContactGroupPriceDisplayButtonProvider" ]): list_response = list_view_func(request) list_response.render() list_content = list_response.content.decode("utf-8") assert "btn-contact-group-hello" in list_content edit_response = edit_view_func(request) edit_response.render() edit_response = edit_response.content.decode("utf-8") assert "btn-contact-group-hello" not in edit_response # use global provider - all views should have that button with override_provides("admin_toolbar_button_provider", [ "shuup.testing.modules.mocker.toolbar:ContactGroupPriceDisplayButtonProvider" ]): list_response = list_view_func(request) list_response.render() list_content = list_response.content.decode("utf-8") assert "btn-contact-group-hello" in list_content edit_response = edit_view_func(request) edit_response.render() edit_response = edit_response.content.decode("utf-8") assert "btn-contact-group-hello" in edit_response
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("campaign_basket_discount_effect_form", []): with override_provides("campaign_basket_line_effect_form", []): 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_contact_detail_has_mocked_toolbar_action_items(rf, admin_user): get_default_shop() contact = create_random_person(locale="en_US", minimum_name_comp_len=5) request = apply_request_middleware(rf.get("/"), user=admin_user) view_func = ContactDetailView.as_view() with override_provides("admin_contact_toolbar_action_item", [ "shuup.testing.admin_module.toolbar:MockContactToolbarActionItem" ]): assert _check_if_mock_action_item_exists(view_func, request, contact) with override_provides("admin_contact_toolbar_action_item", []): assert not _check_if_mock_action_item_exists(view_func, request, contact)
def test_multishops_middleware(rf, host): with override_provides("xtheme", [ "shuup_tests.xtheme.utils:FauxTheme", "shuup_tests.xtheme.utils:FauxTheme2" ]): shop1 = Shop.objects.create(identifier="shop1", domain="shop-1") shop2 = Shop.objects.create(identifier="shop2", domain="shop-test-2") theme_settings_shop1 = ThemeSettings.objects.create(theme_identifier=FauxTheme.identifier, shop=shop1) theme_settings_shop2 = ThemeSettings.objects.create(theme_identifier=FauxTheme2.identifier, shop=shop2) request = rf.get("/") request.META["HTTP_HOST"] = host # should apply the correct shop and the template apply_request_middleware(request) if host == "shop-1.somedomain.com": assert request.shop.id == shop1.id assert get_middleware_current_theme().identifier == FauxTheme.identifier assert get_middleware_current_theme().settings_obj.id == theme_settings_shop1.id else: assert request.shop.id == shop2.id assert get_middleware_current_theme().identifier == FauxTheme2.identifier assert get_middleware_current_theme().settings_obj.id == theme_settings_shop2.id
def test_stacked_tax_taxful_price(): shop = get_shop(prices_include_tax=True, currency='EUR') source = OrderSource(shop) assert source.prices_include_tax source.add_line( type=OrderLineType.OTHER, quantity=1, base_unit_price=source.create_price(20) ) with override_provides("tax_module", TAX_MODULE_SPEC): with override_settings(SHUUP_TAX_MODULE="irvine"): source.shipping_address = MutableAddress( street="16215 Alton Pkwy", postal_code="92602", ) line = source.get_final_lines(with_taxes=True)[0] assert isinstance(line, SourceLine) assert line.taxes assert line.taxful_price == TaxfulPrice(20, 'EUR') assert_almost_equal(line.taxless_price, TaxlessPrice("18.52", 'EUR')) source.uncache() # Let's move out to a taxless location. source.shipping_address.postal_code = "11111" line = source.get_final_lines(with_taxes=True)[0] assert isinstance(line, SourceLine) assert not line.taxes assert line.taxful_price == TaxfulPrice(20, source.currency) assert line.taxless_price.value == Decimal("20")
def test_sorts_and_filter_in_shop_edit(rf, admin_user): cache.clear() activate("en") with override_provides("front_extend_product_list_form", DEFAULT_FORM_MODIFIERS): shop = get_default_shop() view = ShopEditView.as_view() assert get_configuration(shop=shop) == settings.SHUUP_FRONT_DEFAULT_SORT_CONFIGURATION data = { "base-name__en": shop.name, "base-public_name__en": shop.public_name, "base-status": shop.status.value, "base-currency": shop.currency, "base-prices_include_tax": shop.prices_include_tax, "base-languages": "en", "product_list_facets-sort_products_by_name": True, "product_list_facets-sort_products_by_name_ordering": 11, "product_list_facets-sort_products_by_price": False, "product_list_facets-sort_products_by_price_ordering": 32, "product_list_facets-filter_products_by_manufacturer": False, "product_list_facets-filter_products_by_manufacturer_ordering": 1 } request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request, pk=shop.pk) if hasattr(response, "render"): response.render() assert response.status_code in [200, 302] expected_configurations = { "sort_products_by_name": True, "sort_products_by_name_ordering": 11, "sort_products_by_price": False, "sort_products_by_price_ordering": 32, "filter_products_by_manufacturer": False, "filter_products_by_manufacturer_ordering": 1 } assert get_configuration(shop=shop) == expected_configurations
def test_sorts_and_filter_in_category_edit(rf, admin_user): get_default_shop() cache.clear() activate("en") with override_provides("front_extend_product_list_form", DEFAULT_FORM_MODIFIERS): category = get_default_category() view = CategoryEditView.as_view() assert get_configuration(category=category) == settings.SHUUP_FRONT_DEFAULT_SORT_CONFIGURATION data = { "base-name__en": category.name, "base-status": category.status.value, "base-visibility": category.visibility.value, "base-ordering": category.ordering, "product_list_facets-sort_products_by_name": True, "product_list_facets-sort_products_by_name_ordering": 6, "product_list_facets-sort_products_by_price": False, "product_list_facets-sort_products_by_price_ordering": 32, "product_list_facets-filter_products_by_manufacturer": True, "product_list_facets-filter_products_by_manufacturer_ordering": 1 } request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request, pk=category.pk) if hasattr(response, "render"): response.render() assert response.status_code in [200, 302] expected_configurations = { "sort_products_by_name": True, "sort_products_by_name_ordering": 6, "sort_products_by_price": False, "sort_products_by_price_ordering": 32, "filter_products_by_manufacturer": True, "filter_products_by_manufacturer_ordering": 1 } assert get_configuration(category=category) == expected_configurations
def test_provider_provides_fields(rf, admin_user): if "shuup.front.apps.registration" not in settings.INSTALLED_APPS: pytest.skip("shuup.front.apps.registration required in installed apps") shop = get_default_shop() with override_provides("front_registration_field_provider", [ "shuup_tests.front.utils.FieldTestProvider", ]): current_username = "******" request = apply_request_middleware(rf.post("/"), shop=shop) payload = { "username": current_username, "password1": "asdf", "password2": "asdf", "email": "*****@*****.**" } form = PersonRegistrationForm(request=request, data=payload) assert FieldTestProvider.key in form.fields assert not form.is_valid() assert form.errors[FieldTestProvider.key][0] == FieldTestProvider.error_msg # accept terms payload.update({FieldTestProvider.key: True}) form = PersonRegistrationForm(request=request, data=payload) assert FieldTestProvider.key in form.fields assert form.is_valid() # test signal fires person_registration_save.connect(change_username_signal, dispatch_uid="test_registration_change_username") user = form.save() assert user.username != current_username assert user.username == "changed_username" person_registration_save.disconnect(dispatch_uid="test_registration_change_username")
def test_email_auth_form(rf, regular_user): shop = get_default_shop() prepare_user(regular_user) payload = { "username": regular_user.username, "password": REGULAR_USER_PASSWORD, } request = apply_request_middleware(rf.get("/"), shop=shop) with override_provides("front_auth_form_field_provider", ["shuup_tests.front.utils.FieldTestProvider"]): form = EmailAuthenticationForm(request=request, data=payload) assert FieldTestProvider.key in form.fields assert not form.is_valid() assert form.errors[FieldTestProvider.key][0] == FieldTestProvider.error_msg # accept terms payload.update({FieldTestProvider.key: True}) form = EmailAuthenticationForm(request=request, data=payload) assert FieldTestProvider.key in form.fields assert form.is_valid() login_allowed.connect(login_allowed_signal, dispatch_uid="test_login_allowed") with pytest.raises(ValidationError): form.confirm_login_allowed(regular_user) login_allowed.disconnect(dispatch_uid="test_login_allowed") form.confirm_login_allowed(regular_user)
def test_reports_admin_permissions(rf): shop = get_default_shop() # We need a shop to exists staff_user = get_default_staff_user(shop) permission_group = get_default_permission_group() staff_user.groups = [permission_group] request = apply_request_middleware(rf.get("/"), user=staff_user) request.user = staff_user with replace_modules([ReportsAdminModule]): with override_provides("reports", REPORTS): extra_permissions = ReportsAdminModule().get_extra_permissions() assert len(extra_permissions) == 3 assert SalesReport.identifier in extra_permissions assert TotalSales.identifier in extra_permissions assert SalesPerHour.identifier in extra_permissions with admin_only_urls(): view_func = ReportView.as_view() response = view_func(request) response.render() response = view_func(request, pk=None) # "new mode" response.render() assert response.content soup = BeautifulSoup(response.content) assert soup.find("div", {"class": "content-block"}).text == "No reports available" expected_report_identifiers = [] for report_cls in [SalesReport, TotalSales, SalesPerHour]: expected_report_identifiers.append(report_cls.identifier) set_permissions_for_group(permission_group, [report_cls.identifier]) response = view_func(request, pk=None) # "new mode" response.render() assert response.content soup = BeautifulSoup(response.content) for option in soup.find("select", {"id": "id_report"}).findAll("option"): assert option["value"] in expected_report_identifiers
def test_dummy_script_template_manual(rf): with override_provides("notify_script_template", [ "shuup.testing.notify_script_templates:DummyScriptTemplate" ]): get_default_shop() Script.objects.all().delete() script_template = DummyScriptTemplate() form = script_template.get_form() assert form is None script = script_template.create_script() assert script is not None db_script = Script.objects.first() assert script.pk == db_script.pk serialized_steps = db_script.get_serialized_steps() assert len(serialized_steps) == 1 assert len(serialized_steps[0]["actions"]) == 0 assert len(serialized_steps[0]["conditions"]) == 1 assert serialized_steps[0]["conditions"][0]["v1"]["constant"] assert not serialized_steps[0]["conditions"][0]["v2"]["constant"]
def test_extending_shipment_form_valid_hook(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() product = create_product(sku="test-sku", shop=shop, supplier=supplier, default_price=3.33) quantity = 1 order = create_order_with_product( product, supplier, quantity=quantity, taxless_base_unit_price=1, shop=shop) extend_form_class = "shuup_tests.admin.test_shipment_creator.ShipmentFormModifierTest" with override_provides(ShipmentForm.form_modifier_provide_key, [extend_form_class]): phone_number = "+358911" data = { "q_%s" % product.pk: 1, "supplier": supplier.pk, "phone": phone_number } request = apply_request_middleware(rf.post("/", data=data), user=admin_user) view = OrderCreateShipmentView.as_view() response = view(request, pk=order.pk) assert response.status_code == 302 # Order should now have shipment, but let's re fetch it first order = Order.objects.get(pk=order.pk) assert order.shipments.count() == 1 shipment = order.shipments.first() assert order.shipping_data.get(shipment.identifier).get("phone") == phone_number assert shipment.supplier_id == supplier.id assert shipment.products.count() == 1 assert shipment.products.first().product_id == product.id
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 test_reporting(rf): product_price = 100 product_count = 2 tax_rate = Decimal("0.10") line_count = 1 expected_taxful_total, expected_taxless_total, shop, order = initialize_report_test(product_price, product_count, tax_rate, line_count) with override_provides("reports", [__name__ + ":SalesTestReport"]): data = { "report": SalesTestReport.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.THIS_YEAR.value, "writer": "json", "force_download": 1, } view = ReportView.as_view() request = apply_request_middleware(rf.post("/", data=data)) response = view(request) if hasattr(response, "render"): response.render() assert response.status_code == 200 json_data = json.loads(response.content.decode("utf-8")) assert force_text(SalesTestReport.title) in json_data.get("heading") totals = json_data.get("tables")[0].get("totals") return_data = json_data.get("tables")[0].get("data")[0] assert int(totals.get("product_count", 0)) == product_count assert int(return_data.get("product_count", 0)) == product_count assert int(totals.get("order_count", 0)) == 1 assert int(return_data.get("order_count", 0)) == 1 assert str(expected_taxless_total) in totals.get("taxless_total", "0") assert str(expected_taxful_total) in totals.get("taxful_total", "0") today = date.today() last_year = date(today.year-1, 1, 1) next_year = date(today.year+1, 1, 1) # test report without downloading it data = { "report": SalesTestReport.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.CUSTOM.value, "start_date": last_year.strftime("%Y-%m-%d"), "end_date": next_year.strftime("%Y-%m-%d"), "writer": "json", } request = apply_request_middleware(rf.post("/", data=data)) response = view(request) assert response.status_code == 200 soup = BeautifulSoup(response.render().content) soup_text = force_text(soup) assert force_text(SalesTestReport.title) in soup_text assert str(expected_taxless_total) in soup_text assert str(expected_taxful_total) in soup_text
def test_report_writer_populator_provide(): with override_provides("report_writer_populator", [ "shuup.reports.writer.populate_default_writers" ]): populator = ReportWriterPopulator() populator.populate() for k, v in REPORT_WRITERS_MAP.items(): assert populator.populated_map[k] == v
def test_provides(): shop = get_default_shop() product = create_product("test", shop, default_price=20) shop_product = product.get_shop_instance(shop) with override_provides("campaign_catalog_filter", [__name__ + ":UltraFilter"]): uf = UltraFilter.objects.create() uf.products.add(product) assert get_matching_for_product(shop_product, provide_category="campaign_catalog_filter") assert not get_matching_for_product(shop_product, provide_category="test_test_test")
def test_order_detail_info_row_extend(rf, admin_user): shop = get_default_shop() supplier = get_default_supplier() order = _get_order(shop, supplier, True) request = apply_request_middleware(rf.get("/"), user=admin_user) view_func = OrderDetailView.as_view() # Test that context["provided_information"] is empty by default with override_provides("admin_order_information", []): response = view_func(request, pk=order.pk) assert response.context_data['provided_information'] == [] # Test that we can insert extra information rows into Order detail page with override_provides("admin_order_information", [ "shuup_tests.admin.test_order_detail_extensibility:PaymentMethodName", ]): response = view_func(request, pk=order.pk) soup = BeautifulSoup(response.render().content) assert soup.find_all(text="This is row data")
def test_order_detail_has_default_toolbar_action_items(rf, admin_user, has_price): shop = get_default_shop() supplier = get_default_supplier() order = _get_order(shop, supplier, has_price) request = apply_request_middleware(rf.get("/"), user=admin_user) view_func = OrderDetailView.as_view() create_payment_url = reverse("shuup_admin:order.create-payment", kwargs={"pk": order.pk}) set_paid_url = reverse("shuup_admin:order.set-paid", kwargs={"pk": order.pk}) with override_provides("admin_order_toolbar_action_item", [ "shuup.admin.modules.orders.toolbar:CreatePaymentAction", "shuup.admin.modules.orders.toolbar:SetPaidAction", ]): if has_price: assert _check_if_link_exists(view_func, request, order, create_payment_url) else: assert _check_if_button_exists(view_func, request, order, set_paid_url) with override_provides("admin_order_toolbar_action_item", []): assert not _check_if_link_exists(view_func, request, order, create_payment_url)
def test_product_view_extra_context(rf, admin_user): product = get_default_product() request = apply_request_middleware(rf.get("/"), user=admin_user) view_func = ProductDetailView.as_view() # Test that we can insert extra information into ProductDetailView context with override_provides("product_context_extra", [ "shuup_tests.front.test_product:ExtraContextTest", ]): response = view_func(request, pk=product.pk) assert response.context_data['product_sku'] == product.sku
def initialize_editor_view(view_name, placeholder_name, request=None): if request is None: request = RequestFactory().get("/") request.user = SuperUser() if hasattr(request.GET, "_mutable"): request.GET._mutable = True # Ahem request.GET.update({"theme": FauxTheme.identifier, "view": view_name, "ph": placeholder_name}) with plugin_override(): with override_provides("xtheme", ["shuup_tests.xtheme.utils:FauxTheme"]): with override_current_theme_class(FauxTheme): yield EditorView(request=request, args=(), kwargs={})
def test_simple_addon_injection(): request = get_request(edit=False) jeng = get_jinja2_engine() template = jeng.get_template("resinject.jinja") with override_current_theme_class(): with override_provides( "xtheme_resource_injection", ["shuup_tests.xtheme.test_addon_injections:add_test_injection",]): # TestInjector should add alert to end of the body for every request output = template.render(request=request) head, body = output.split("</head>", 1) assert "window.injectedFromAddon=true;" in body
def test_get_placeholder_layouts(): vc = _get_basic_view_config() product = factories.create_product("test", name="Test product name") category = factories.get_default_category() placeholder_name = "hermit" context = {"request": get_request(), "product": product, "category": category} provides = [] with override_provides("xtheme_layout", provides): assert len(vc.get_placeholder_layouts(context, placeholder_name)) == 1 # Default layout provides.append("shuup.xtheme.layout.ProductLayout") with override_provides("xtheme_layout", provides): assert len(vc.get_placeholder_layouts(context, placeholder_name)) == 2 provides.append("shuup.xtheme.layout.CategoryLayout") with override_provides("xtheme_layout", provides): assert len(vc.get_placeholder_layouts(context, placeholder_name)) == 3 provides.append("shuup.xtheme.layout.AnonymousContactLayout") with override_provides("xtheme_layout", provides): assert len(vc.get_placeholder_layouts(context, placeholder_name)) == 4
def test_theme_activation(): with override_current_theme_class(): with override_provides("xtheme", [ "shuup_tests.xtheme.utils:FauxTheme", "shuup_tests.xtheme.utils:FauxTheme2" ]): ThemeSettings.objects.all().delete() assert not get_current_theme() set_current_theme(FauxTheme.identifier) assert isinstance(get_current_theme(), FauxTheme) set_current_theme(FauxTheme2.identifier) assert isinstance(get_current_theme(), FauxTheme2) with pytest.raises(ValueError): set_current_theme(printable_gibberish())
def test_theme_activation(): cache.init_cache() shop = get_default_shop() with override_provides("xtheme", [ "shuup_tests.xtheme.utils:FauxTheme", "shuup_tests.xtheme.utils:FauxTheme2" ]): set_current_theme(FauxTheme.identifier, shop) assert isinstance(get_current_theme(shop), FauxTheme) set_current_theme(FauxTheme2.identifier, shop) assert isinstance(get_current_theme(shop), FauxTheme2) with pytest.raises(ValueError): set_current_theme(printable_gibberish(), shop)
def test_get_by_identifier_theme(rf): with override_provides("xtheme", [ "shuup_tests.xtheme.utils:FauxTheme", "shuup_tests.xtheme.utils:FauxTheme2" ]): shop1 = Shop.objects.create(identifier="shop1", domain="shop-1") shop2 = Shop.objects.create(identifier="shop2", domain="shop-test-2") theme = get_theme_by_identifier(FauxTheme2.identifier, shop1) assert theme.settings_obj.theme_identifier == FauxTheme2.identifier assert theme.settings_obj.shop.id == shop1.id theme = get_theme_by_identifier(FauxTheme.identifier, shop2) assert theme.settings_obj.theme_identifier == FauxTheme.identifier assert theme.settings_obj.shop.id == shop2.id
def test_theme_settings_api(): with override_provides("xtheme", [ "shuup_tests.xtheme.utils:FauxTheme", "shuup_tests.xtheme.utils:FauxTheme2" ]): ThemeSettings.objects.all().delete() theme = get_theme_by_identifier(FauxTheme2.identifier) theme.set_setting("foo", "bar") theme.set_settings(quux=[4, 8, 15, 16, 23, 42]) theme = get_theme_by_identifier(FauxTheme2.identifier) assert theme.get_setting("foo") == "bar" assert theme.get_settings() == { "foo": "bar", "quux": [4, 8, 15, 16, 23, 42] }
def plugin_override(): return override_provides("xtheme_plugin", [ "shuup.xtheme.plugins.text:TextPlugin", "shuup_tests.xtheme.test_resources:ResourceInjectorPlugin" ])
def test_extendable_helper_ns(): with override_provides("front_template_helper_namespace", ["%s:TestNs" % __name__]): ns = _get_helpers() assert ns.badgers.snake()
def test_theme_selection(): cache.clear() shop = factories.get_default_shop() theme = get_current_theme(shop) test_js_script = 'console.log("this is JS snippet");' js_snippet = Snippet.objects.create(shop=shop, location="body_end", snippet_type=SnippetType.InlineJS, snippet=test_js_script, themes=theme.identifier) test_css_style = 'h1 { font-size: 3px; }' css_snippet = Snippet.objects.create(shop=shop, location="head_end", snippet_type=SnippetType.InlineCSS, snippet=test_css_style, themes=theme.identifier) test_html_code = '<p class="test-snippet">Test HTML snippet</p>' html_snippet = Snippet.objects.create( shop=shop, location="body_end", snippet_type=SnippetType.InlineHTMLMarkup, snippet=test_html_code, themes=theme.identifier) test_jinja_code = '<p class="test-snippet">Test Jinja snippet %s</p>' jinja_snippet = Snippet.objects.create( shop=shop, location="body_end", snippet_type=SnippetType.InlineJinjaHTMLMarkup, snippet=test_jinja_code % ('{{ request.shop.public_name}}')) html_that_should_not_exist = "<h1>-Hello world</h1>" snippet_for_other_theme = Snippet.objects.create( shop=shop, location="body_end", snippet_type=SnippetType.InlineHTMLMarkup, snippet=html_that_should_not_exist, themes="random.theme") with override_provides("xtheme_resource_injection", ["shuup.xtheme.resources:inject_global_snippet"]): client = SmartClient() response, soup = client.response_and_soup("/") assert response.status_code == 200 assert html_that_should_not_exist not in str(soup) body = str(soup.find("body")) assert "<script>%s</script>" % test_js_script in body assert test_html_code in body assert (test_jinja_code % shop.public_name) in body head = str(soup.find("head")) assert '<style type="text/css">%s</style>' % test_css_style in head # Admin views are not allowed to inject into client = SmartClient() response, soup = client.response_and_soup("/sa/login/") assert response.status_code == 200 soup_str = str(soup) assert html_that_should_not_exist not in soup_str assert ('<style type="text/css">%s</style>' % test_css_style) not in soup_str
def test_provider_provides_definitions(rf, admin_user): if "shuup.front.apps.registration" not in settings.INSTALLED_APPS: pytest.skip("shuup.front.apps.registration required in installed apps") shop = get_default_shop() with override_provides("front_company_registration_form_provider", ["shuup_tests.front.utils.FormDefTestProvider"]): with override_provides("front_registration_field_provider", ["shuup_tests.front.utils.FieldTestProvider"]): request = apply_request_middleware(rf.post("/"), shop=shop) current_username = "******" current_name = "123" payload = { 'company-tax_number': "123", 'company-name': current_name, 'billing-country': "US", 'billing-city': "city", 'billing-street': "street", 'contact_person-last_name': "last", 'contact_person-first_name': "first", 'contact_person-email': "*****@*****.**", 'user_account-password1': "asdf123", 'user_account-password2': "asdf123", 'user_account-username': current_username } form_group = CompanyRegistrationForm(request=request, data=payload) assert FormDefTestProvider.test_name in form_group.form_defs # test CompanyRegistrationForm itself assert "company" in form_group.form_defs assert "billing" in form_group.form_defs assert "contact_person" in form_group.form_defs assert "user_account" in form_group.form_defs assert form_group.form_defs["billing"].form_class == cached_load( 'SHUUP_ADDRESS_MODEL_FORM') assert not form_group.is_valid() assert FormDefTestProvider.test_name in form_group.errors assert FieldTestProvider.key in form_group.errors[ FormDefTestProvider.test_name] assert len(form_group.errors) == 1 # no other errors key = "%s-%s" % (FormDefTestProvider.test_name, FieldTestProvider.key) payload.update({key: 1}) form_group = CompanyRegistrationForm(request=request, data=payload) assert FormDefTestProvider.test_name in form_group.form_defs assert form_group.is_valid() assert FormDefTestProvider.test_name not in form_group.errors assert not len(form_group.errors) # no errors # test signal fires company_registration_save.connect( change_company_signal, dispatch_uid="test_registration_change_company_signal") form_group.save(commit=True) assert not User.objects.filter(username=username).exists() assert not CompanyContact.objects.filter( name=current_name).exists() assert User.objects.filter(username="******").exists() assert CompanyContact.objects.filter(name="changed_name").exists() company_registration_save.disconnect( dispatch_uid="test_registration_change_company_signal")
def get_form_parts(request, view, object): with override_provides("service_behavior_component_form", DEFAULT_BEHAVIOR_FORMS): with override_provides("service_behavior_component_form_part", DEFAULT_BEHAVIOR_FORM_PARTS): initialized_view = view(request=request, kwargs={"pk": object.pk}) return initialized_view.get_form_parts(object)
def layout_override(): return override_provides("xtheme_layout", [])
def test_reporting(rf, admin_user): product_price = 100 product_count = 2 tax_rate = Decimal("0.10") line_count = 1 expected_taxful_total, expected_taxless_total, shop, order = initialize_report_test( product_price, product_count, tax_rate, line_count) with override_provides("reports", [__name__ + ":SalesTestReportForRequestTets"]): data = { "report": SalesTestReport.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.THIS_YEAR.value, "writer": "json", "force_download": 1, } view = ReportView.as_view() request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request) if hasattr(response, "render"): response.render() assert response.status_code == 200 json_data = json.loads(response.content.decode("utf-8")) assert force_text(SalesTestReport.title) in json_data.get("heading") totals = json_data.get("tables")[0].get("totals") return_data = json_data.get("tables")[0].get("data")[0] assert int(totals.get("product_count", 0)) == product_count assert int(return_data.get("product_count", 0)) == product_count assert int(totals.get("order_count", 0)) == 1 assert int(return_data.get("order_count", 0)) == 1 assert str(expected_taxless_total) in totals.get("taxless_total", "0") assert str(expected_taxful_total) in totals.get("taxful_total", "0") today = date.today() last_year = date(today.year - 1, 1, 1) next_year = date(today.year + 1, 1, 1) # test report without downloading it data = { "report": SalesTestReport.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.CUSTOM.value, "start_date": last_year.strftime("%Y-%m-%d"), "end_date": next_year.strftime("%Y-%m-%d"), "writer": "json", } request = apply_request_middleware(rf.post("/", data=data), user=admin_user) response = view(request) assert response.status_code == 200 soup = BeautifulSoup(response.render().content) response_text = str(six.u(soup.encode("ascii"))) assert force_text(SalesTestReport.title) in response_text assert str(expected_taxless_total) in response_text assert str(expected_taxful_total) in response_text
def test_product_total_sales_report(rf, order_by): with override_provides("reports", [ "shuup.default_reports.reports.product_total_sales:ProductSalesReport" ]): shop = get_default_shop() supplier = get_default_supplier() product1 = create_product("product1", supplier=supplier, shop=shop) product2 = create_product("product2", supplier=supplier, shop=shop) p1_qtd, p1_price, p1_tr, p1_lines = Decimal(3), Decimal(5), Decimal( 0), 5 p2_qtd, p2_price, p2_tr, p2_lines = Decimal(4), Decimal(5), Decimal( 0.95), 3 order = create_order_with_product(product=product1, supplier=supplier, quantity=p1_qtd, taxless_base_unit_price=p1_price, tax_rate=p1_tr, n_lines=p1_lines, shop=shop) order.create_payment(order.taxful_total_price.amount) order2 = create_order_with_product(product=product2, supplier=supplier, quantity=p2_qtd, taxless_base_unit_price=p2_price, tax_rate=p2_tr, n_lines=p2_lines, shop=shop) order2.create_payment(order2.taxful_total_price.amount) data = { "report": ProductSalesReport.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.ALL_TIME.value, "writer": "json", "force_download": 1, "order_by": order_by } view = ReportView.as_view() request = apply_request_middleware(rf.post("/", data=data)) response = view(request) if hasattr(response, "render"): response.render() assert response.status_code == 200 json_data = json.loads(response.content.decode("utf-8")) assert force_text(ProductSalesReport.title) in json_data.get("heading") data = json_data["tables"][0]["data"] assert len(data) == 2 p1_total_qtd = p1_qtd * p1_lines p1_taxless_total = p1_total_qtd * p1_price p1_taxful_total = p1_taxless_total * (1 + p1_tr) p2_total_qtd = p2_qtd * p2_lines p2_taxless_total = p2_total_qtd * p2_price p2_taxful_total = p2_taxless_total * (1 + p2_tr) if order_by == "quantity": p1 = data[0] p2 = data[1] elif order_by == "taxless_total": p1 = data[0] p2 = data[1] else: # order_by == "taxful_total": p1 = data[1] p2 = data[0] precision = Decimal('0.1')**2 assert p1["product"] == product1.name assert Decimal(p1["quantity"]) == p1_total_qtd assert Decimal( p1["taxless_total"]) == p1_taxless_total.quantize(precision) assert Decimal( p1["taxful_total"]) == p1_taxful_total.quantize(precision) assert p2["product"] == product2.name assert Decimal(p2["quantity"]) == p2_total_qtd assert Decimal( p2["taxless_total"]) == p2_taxless_total.quantize(precision) assert Decimal( p2["taxful_total"]) == p2_taxful_total.quantize(precision)
def test_new_customers_report(rf, group_by): with override_provides( "reports", ["shuup.default_reports.reports.new_customers:NewCustomersReport"]): shop = get_default_shop() person_creation_dates = [ datetime(2015, 1, 2), datetime(2015, 1, 1), datetime(2016, 2, 2), ] # create person with NO user for creation_date in person_creation_dates: person = create_random_person() person.created_on = creation_date person.save() user_person_creation_dates = [ datetime(2015, 3, 3), datetime(2015, 3, 3), datetime(2015, 4, 4), datetime(2016, 5, 5), datetime(2016, 6, 6), datetime(2016, 7, 7), ] # create person with users for creation_date in user_person_creation_dates: person = create_random_person() person.user = UserFactory() person.created_on = creation_date person.save() company_creation_dates = [ datetime(2015, 1, 1), datetime(2015, 8, 8), datetime(2015, 9, 9), ] # create company contacts for creation_date in company_creation_dates: company = CompanyFactory() company.created_on = creation_date company.save() data = { "report": NewCustomersReport.get_name(), "shop": shop.pk, "date_range": DateRangeChoices.ALL_TIME.value, "writer": "json", "force_download": 1, "group_by": group_by } view = ReportView.as_view() request = apply_request_middleware(rf.post("/", data=data)) response = view(request) if hasattr(response, "render"): response.render() assert response.status_code == 200 json_data = json.loads(response.content.decode("utf-8")) assert force_text(NewCustomersReport.title) in json_data.get("heading") data = json_data["tables"][0]["data"] if group_by == "%Y": assert len(data) == 2 assert data[0]["date"] == "2015" assert int(data[0]["personcontact"]) == 5 assert int(data[0]["companycontact"]) == 3 assert int(data[0]["users"]) == 3 assert data[1]["date"] == "2016" assert int(data[1]["personcontact"]) == 4 assert int(data[1]["companycontact"]) == 0 assert int(data[1]["users"]) == 3 elif group_by == "%Y-%m": assert len(data) == 9 assert data[0]["date"] == "2015-01" assert int(data[0]["personcontact"]) == 2 assert int(data[0]["companycontact"]) == 1 assert int(data[0]["users"]) == 0 assert data[1]["date"] == "2015-03" assert int(data[1]["personcontact"]) == 2 assert int(data[1]["companycontact"]) == 0 assert int(data[1]["users"]) == 2 assert data[2]["date"] == "2015-04" assert int(data[2]["personcontact"]) == 1 assert int(data[2]["companycontact"]) == 0 assert int(data[2]["users"]) == 1 assert data[3]["date"] == "2015-08" assert int(data[3]["personcontact"]) == 0 assert int(data[3]["companycontact"]) == 1 assert int(data[3]["users"]) == 0 assert data[4]["date"] == "2015-09" assert int(data[4]["personcontact"]) == 0 assert int(data[4]["companycontact"]) == 1 assert int(data[4]["users"]) == 0 assert data[5]["date"] == "2016-02" assert int(data[5]["personcontact"]) == 1 assert int(data[5]["companycontact"]) == 0 assert int(data[5]["users"]) == 0 assert data[6]["date"] == "2016-05" assert int(data[6]["personcontact"]) == 1 assert int(data[6]["companycontact"]) == 0 assert int(data[6]["users"]) == 1 assert data[7]["date"] == "2016-06" assert int(data[7]["personcontact"]) == 1 assert int(data[7]["companycontact"]) == 0 assert int(data[7]["users"]) == 1 assert data[8]["date"] == "2016-07" assert int(data[8]["personcontact"]) == 1 assert int(data[8]["companycontact"]) == 0 assert int(data[8]["users"]) == 1 elif group_by == "%Y-%m-%d": assert len(data) == 10 assert data[0]["date"] == "2015-01-01" assert int(data[0]["personcontact"]) == 1 assert int(data[0]["companycontact"]) == 1 assert int(data[0]["users"]) == 0 assert data[1]["date"] == "2015-01-02" assert int(data[1]["personcontact"]) == 1 assert int(data[1]["companycontact"]) == 0 assert int(data[1]["users"]) == 0 assert data[2]["date"] == "2015-03-03" assert int(data[2]["personcontact"]) == 2 assert int(data[2]["companycontact"]) == 0 assert int(data[2]["users"]) == 2 assert data[3]["date"] == "2015-04-04" assert int(data[3]["personcontact"]) == 1 assert int(data[3]["companycontact"]) == 0 assert int(data[3]["users"]) == 1 assert data[4]["date"] == "2015-08-08" assert int(data[4]["personcontact"]) == 0 assert int(data[4]["companycontact"]) == 1 assert int(data[4]["users"]) == 0 assert data[5]["date"] == "2015-09-09" assert int(data[5]["personcontact"]) == 0 assert int(data[5]["companycontact"]) == 1 assert int(data[5]["users"]) == 0 assert data[6]["date"] == "2016-02-02" assert int(data[6]["personcontact"]) == 1 assert int(data[6]["companycontact"]) == 0 assert int(data[6]["users"]) == 0 assert data[7]["date"] == "2016-05-05" assert int(data[7]["personcontact"]) == 1 assert int(data[7]["companycontact"]) == 0 assert int(data[7]["users"]) == 1 assert data[8]["date"] == "2016-06-06" assert int(data[8]["personcontact"]) == 1 assert int(data[8]["companycontact"]) == 0 assert int(data[8]["users"]) == 1 assert data[9]["date"] == "2016-07-07" assert int(data[9]["personcontact"]) == 1 assert int(data[9]["companycontact"]) == 0 assert int(data[9]["users"]) == 1
# # This source code is licensed under the OSL-3.0 license found in the # LICENSE file in the root directory of this source tree. import decimal import pytest from django.conf import settings from shuup.apps.provides import override_provides from shuup.core.pricing import (DiscountModule, get_price_info, get_price_infos, get_pricing_steps, get_pricing_steps_for_products) from shuup.testing.factories import create_product, get_default_shop from shuup.testing.utils import apply_request_middleware provide_overrider = override_provides("discount_module", [__name__ + ':Minus25DiscountModule']) def setup_module(module): global original_pricing_module global original_discount_modules original_pricing_module = settings.SHUUP_PRICING_MODULE original_discount_modules = settings.SHUUP_DISCOUNT_MODULES settings.SHUUP_PRICING_MODULE = "default_pricing" settings.SHUUP_DISCOUNT_MODULES = ["minus25"] provide_overrider.__enter__() def teardown_module(module):
def test_provide_columns(): with override_provides("provided_columns_ShopProduct", [ "shuup_tests.admin.test_picotable:CustomProductDataColumn"]): view_settings = ViewSettings(ShopProduct, ProductListView.default_columns, ProductListView) column_ids = [col.id for col in view_settings.inactive_columns] # provided column is not set active yet assert "custom_product_info" in column_ids
def test_dummy_script_editor(browser, admin_user, live_server, settings): initialize(browser, live_server, settings) with override_provides( "notify_script_template", ["shuup.testing.notify_script_templates:DummyScriptTemplate"]): url = reverse("shuup_admin:notify.script.list") browser.visit("%s%s" % (live_server, url)) wait_until_condition( browser, lambda x: x.is_element_present_by_css( ".shuup-toolbar a.btn.btn-default")) post_initialize() # find the button to load from template browser.find_by_css(".shuup-toolbar a.btn.btn-default").first.click() identifier = DummyScriptTemplate.identifier form_id = "form-" + identifier wait_until_condition(browser, lambda x: x.is_element_present_by_id(form_id)) btn_create_css = "#{} button.btn.btn-success".format(form_id) wait_until_condition( browser, lambda x: x.is_element_present_by_css(btn_create_css)) click_element(browser, btn_create_css) wait_until_condition( browser, lambda b: b.url.endswith( reverse("shuup_admin:notify.script.list"))) script = Script.objects.first() serialized_steps = script.get_serialized_steps() assert len(serialized_steps) == 1 assert len(serialized_steps[0]["actions"]) == 0 assert len(serialized_steps[0]["conditions"]) == 1 assert serialized_steps[0]["conditions"][0]["v1"]["constant"] assert not serialized_steps[0]["conditions"][0]["v2"]["constant"] # edit the script url = reverse("shuup_admin:notify.script.edit", kwargs={"pk": script.pk}) browser.visit("%s%s" % (live_server, url)) wait_until_condition( browser, lambda b: b.is_text_present("Edit Script Information")) # should exist only a single button to edit the script content assert len( browser.find_by_css(".shuup-toolbar a.btn.btn-primary")) == 1 assert "Edit Script Contents" in browser.find_by_css( ".shuup-toolbar a.btn.btn-primary").first.text click_element(browser, ".shuup-toolbar a.btn.btn-primary") wait_until_condition(browser, lambda b: b.is_text_present("New action")) browser.find_by_css(".btn-primary")[1].click() wait_until_condition(browser, lambda b: b.is_text_present("Send Email")) browser.find_by_css(".item-option .item-name")[2].click() with browser.get_iframe("step-item-frame") as iframe: iframe.find_by_id("id_b_recipient_c").fill("*****@*****.**") iframe.find_by_name("b_language_c").fill("English") click_element(iframe, ".btn.btn-success") wait_until_condition( iframe, lambda b: b.is_text_present( "Please correct the errors below.")) browser.find_by_css(".nav-link")[1].click() wait_until_condition( iframe, lambda b: b.is_text_present("This field is missing content") ) # Assert that only the default shop language requires fields if len(settings.LANGUAGES) > 1: browser.find_by_css(".nav-link")[2].click() assert not iframe.is_text_present( "This field is missing content" ) # Assert that another language doesn't contain content browser.find_by_css(".nav-link")[1].click() iframe.find_by_id("id_t_en_subject").fill("Random subject") iframe.find_by_css(".note-editable.card-block").fill( "<p>Lorem ipsum et cetera</p>") click_element(iframe, ".btn.btn-success") click_element(browser, ".btn.btn-success") wait_until_condition(browser, lambda b: b.is_text_present("send_email") ) # Check if email step has been added
from shuup.apps.provides import override_provides from shuup.core.models import (AnonymousContact, Order, OrderLine, OrderLineType, Product, Shop) from shuup.core.order_creator import OrderSource from shuup.core.pricing import (get_pricing_module, PriceDisplayOptions, PriceInfo, PricingModule, TaxfulPrice, TaxlessPrice) from shuup.front.basket.objects import BaseBasket from shuup.testing.factories import (create_default_tax_rule, get_default_tax, get_default_tax_class) PRICING_MODULE_SPEC = __name__ + ':DummyPricingModule' original_pricing_module = settings.SHUUP_PRICING_MODULE original_discount_modules = settings.SHUUP_DISCOUNT_MODULES pricing_overrider = override_provides("pricing_module", [PRICING_MODULE_SPEC]) def setup_module(module): settings.SHUUP_PRICING_MODULE = "dummy_pricing_module" settings.SHUUP_DISCOUNT_MODULES = [] pricing_overrider.__enter__() def teardown_module(module): pricing_overrider.__exit__(None, None, None) settings.SHUUP_PRICING_MODULE = original_pricing_module settings.SHUUP_DISCOUNT_MODULES = original_discount_modules class DummyPricingModule(PricingModule):
from shuup.apps.provides import override_provides from shuup.core.models import ( AnonymousContact, Product, Shop, Tax, TaxClass ) from shuup.core.pricing import PriceInfo, TaxfulPrice, TaxlessPrice from shuup.core.taxing import SourceLineTax, TaxedPrice, TaxModule from shuup.core.utils.prices import convert_taxness from shuup.utils.money import Money TAX_MODULE_SPEC = __name__ + ':DummyTaxModule' original_tax_module = settings.SHUUP_TAX_MODULE tax_mod_overrider = override_provides("tax_module", [TAX_MODULE_SPEC]) def setup_module(module): settings.SHUUP_TAX_MODULE = "dummy_tax_module" tax_mod_overrider.__enter__() def teardown_module(module): tax_mod_overrider.__exit__(None, None, None) settings.SHUUP_TAX_MODULE = original_tax_module class DummyTaxModule(TaxModule): calculations_done = 0
def get_form_parts(request, view, object): with override_provides("campaign_basket_condition", DEFAULT_CONDITION_FORMS): with override_provides("campaign_basket_discount_effect_form", DEFAULT_DISCOUNT_EFFECT_FORMS): with override_provides("campaign_basket_line_effect_form", DEFAULT_LINE_EFFECT_FORMS): initialized_view = view(request=request, kwargs={"pk": object.pk}) return initialized_view.get_form_parts(object)