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