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)
