def test_summernote_editor_picture(browser, admin_user, live_server, settings): activate("en") factories.get_default_shop() factories.get_default_product_type() factories.get_default_sales_unit() factories.get_default_tax_class() filer_image = factories.get_random_filer_image() initialize_admin_browser_test(browser, live_server, settings) browser.driver.set_window_size(1920, 1080) url = reverse("E-Commerce_admin:shop_product.new") browser.visit("%s%s" % (live_server, url)) wait_until_condition(browser, condition=lambda x: x.is_text_present("New shop product")) img_icon_selector = "#id_base-description__en-editor-wrap i[class='note-icon-picture']" move_to_element(browser, img_icon_selector) click_element(browser, img_icon_selector) wait_until_condition(browser, lambda b: len(b.windows) == 2) # change to the media browser window browser.windows.current = browser.windows[1] # click to select the picture wait_until_appeared(browser, "a.file-preview") click_element(browser, "a.file-preview") # back to the main window wait_until_condition(browser, lambda b: len(b.windows) == 1) browser.windows.current = browser.windows[0] # make sure the image was added to the editor wait_until_appeared( browser, "#id_base-description__en-editor-wrap .note-editable img[src='%s']" % filer_image.url, timeout=20)
def test_set_non_shop_member_customer(rf): """ Set some customer to the basket that is not member of the shop """ with override_settings(**CORE_BASKET_SETTINGS): shop = factories.get_shop(False) assert shop != factories.get_default_shop() user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) assert basket.shop == factories.get_default_shop() person = factories.create_random_person() person.shops.add(shop) company = factories.create_random_company() company.add_to_shop(shop) for customer in [person, company]: with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, customer) assert exc.value.code == "invalid_customer_shop" assert basket.customer == get_person_contact(user)
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", [ "E-Commerce.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", [ "E-Commerce.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_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", [ "E-Commerce.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", [ "E-Commerce.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_update_injection(): shop = factories.get_default_shop() client = SmartClient() index_url = reverse("E-Commerce:index") page = ensure_gdpr_privacy_policy(shop) shop_gdpr = GDPRSettings.get_for_shop(shop) shop_gdpr.enabled = True shop_gdpr.privacy_policy = page shop_gdpr.save() assert_update(client, index_url, False) # nothing consented in past, should not show user = factories.create_random_user("en") password = "******" user.set_password(password) user.save() client.login(username=user.username, password=password) assert_update(client, index_url, False) # no consent given, should not be visible create_user_consent_for_all_documents(shop, user) assert_update(client, index_url, False) with reversion.create_revision(): page.save() assert not is_documents_consent_in_sync(shop, user) assert_update(client, index_url, True) # consent client.get(reverse("E-Commerce:gdpr_policy_consent", kwargs=dict(page_id=page.pk))) assert is_documents_consent_in_sync(shop, user) assert_update(client, index_url, False)
def test_force_views_only_for_staff(rf): shop = factories.get_default_shop() user = factories.create_random_user(is_staff=True) person_contact = get_person_contact(user) # Start forcing. There shouldn't be any changes to # request customer due calling the force functions since # those just do the redirect in case the current is user # is not shop staff. request = apply_request_middleware(rf.get("/"), user=user) assert request.customer == person_contact _call_force_view(request, force_anonymous_contact) request = apply_request_middleware(rf.get("/"), user=user) assert request.customer == person_contact _call_force_view(request, force_person_contact) request = apply_request_middleware(rf.get("/"), user=user) assert request.customer == person_contact _call_force_view(request, force_company_contact) request = apply_request_middleware(rf.get("/"), user=user) assert request.customer == person_contact assert get_company_contact(user) is None
def test_company_contact_for_shop_staff(rf, admin_user): company_contact = get_company_contact(admin_user) assert company_contact is None shop = factories.get_default_shop() # Let's create shop for the shop staff company_contact = get_company_contact_for_shop_staff(shop, admin_user) company_contact = get_company_contact_for_shop_staff(shop, admin_user) assert company_contact is not None # Let's create second staff member to make sure all good with # creating company contact for shop staff. new_staff_user = factories.create_random_user() with pytest.raises(AssertionError): get_company_contact_for_shop_staff(shop, new_staff_user) new_staff_user.is_staff = True new_staff_user.save() with pytest.raises(AssertionError): # Since the new staff is not in shop members. The admin user # passed since he is also superuser. get_company_contact_for_shop_staff(shop, new_staff_user) shop.staff_members.add(new_staff_user) assert company_contact == get_company_contact_for_shop_staff(shop, new_staff_user) # Make sure both user has person contact linked to the company contact company_members = company_contact.members.all() assert get_person_contact(admin_user) in company_members assert get_person_contact(new_staff_user) in company_members
def test_manufacturer_filter_get_fields(rf): cache.clear() shop = factories.get_default_shop() request = apply_request_middleware(rf.get("/")) assert ManufacturerProductListFilter().get_fields(request, None) is None manufacturer = Manufacturer.objects.create(name="Random Brand Inc") assert ManufacturerProductListFilter().get_fields(request, None) is None category = factories.get_default_category() product = factories.create_product("sku", shop=shop) shop_product = product.get_shop_instance(shop=shop) shop_product.primary_category = category shop_product.save() assert ManufacturerProductListFilter().get_fields(request, category) is None # Now once we link manufacturer to product we should get # form field for manufacturer product.manufacturer = manufacturer product.save() form_field = ManufacturerProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert form_field.label == "Manufacturers" with override_settings(E-Commerce_FRONT_OVERRIDE_SORTS_AND_FILTERS_LABELS_LOGIC={"manufacturers": "Brands"}): form_field = ManufacturerProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert form_field.label == "Brands"
def test_email_action_with_template_body(): with override_settings(LANGUAGES=(("en", "en"))): SUPER_TEST_TEMPLATE_DATA = { "en": { # English "subject": "Hello, {{ name }}!", "body_template": "<html><style>.dog-color { color: red; }</style><body>%html_body%</body></html>", "body": "Hi, {{ name }}. This is a test.", "content_type": "plain" } } if settings.EMAIL_BACKEND != 'django.core.mail.backends.locmem.EmailBackend': pytest.skip("Need locmem email backend") mail.outbox = [] # Clear the Django testing mail outbox event = get_initialized_test_event() ctx = Context.from_event(event, shop=factories.get_default_shop()) ctx.set("name", "Luke J. Warm") # This variable isn't published by the event, but it's used by the template se = SendEmail({ "template_data": SUPER_TEST_TEMPLATE_DATA, "from_email": {"constant": "*****@*****.**"}, "recipient": {"constant": "*****@*****.**"}, "language": {"constant": "ja"}, }) se.execute(ctx) # Once assert len(mail.outbox) == 1 # 'send_identifier' should ensure this is true msg = mail.outbox[0] assert msg.to == ['*****@*****.**'] assert msg.from_email == '*****@*****.**' assert ".dog-color { color: red; }" in msg.body assert "Luke J. Warm" in msg.body
def test_shop_remove_available_languages(admin_user): shop = factories.get_default_shop() client = SmartClient() with override_settings( LANGUAGES=[ ("en", "English"), ("fi", "Finnish"), ], LANGUAGE_CODE="en", PARLER_DEFAULT_LANGUAGE_CODE = "en" ): # there is no language set for the shop, the first one will be used response = client.get(reverse("E-Commerce:index")) assert get_language() == "en" # request js catalog file response = client.get(reverse("E-Commerce:js-catalog")) assert get_language() == "en" # when requesting admin js catalog, the language should be any of the available client.get("E-Commerce_admin:js-catalog") assert get_language() == "en" set_shop_available_languages(shop, ["fi"]) response = client.get(reverse("E-Commerce:index")) assert get_language() == "fi" response = client.get(reverse("E-Commerce:js-catalog")) assert get_language() == "fi" client.get("E-Commerce_admin:js-catalog") assert get_language() == "en"
def test_product_price(client): shop = factories.get_default_shop() product = factories.create_product("sku", shop=shop, default_price=30) shop_product = product.get_shop_instance(shop) supplier_data = [ ("Johnny Inc", 30), ("Mike Inc", 20), ("Simon Inc", 10), ] for name, product_price in supplier_data: supplier = Supplier.objects.create(name=name) shop_product.suppliers.add(supplier) SupplierPrice.objects.create(supplier=supplier, shop=shop, product=product, amount_value=product_price) strategy = "E-Commerce.testing.supplier_pricing.supplier_strategy:CheapestSupplierPriceSupplierStrategy" with override_settings(E-Commerce_PRICING_MODULE="supplier_pricing", E-Commerce_SHOP_PRODUCT_SUPPLIERS_STRATEGY=strategy): for name, price in supplier_data: supplier = Supplier.objects.get(name=name) response = client.get( reverse('E-Commerce:xtheme_extra_view', kwargs={ 'view': 'product_price' } ) + "?id=%s&quantity=%s&supplier=%s" % (product.pk, 1, supplier.pk) ) soup = BeautifulSoup(response.content) price_span = soup.find("span", {"class": "product-price"}) assert "%s" % price in price_span.text
def test_happy_hours_admin_edit_view_over_midnight(rf, staff_user, admin_user): shop = factories.get_default_shop() shop.staff_members.add(staff_user) factories.get_shop(identifier="shop2", enabled=True) assert Shop.objects.count() == 2 # Staff user gets shop automatically from_hour = datetime.time(hour=21, minute=0) to_hour = datetime.time(hour=3, minute=0) data = { "name": "Happiest Hour 2pm", "weekdays": [1], # Tue "from_hour": from_hour, "to_hour": to_hour } request = apply_request_middleware(rf.post("/", data=data), user=staff_user, shop=shop) set_shop(request, shop) assert request.shop == shop view_func = HappyHourEditView.as_view() response = view_func(request) if hasattr(response, "render"): response.render() assert response.status_code == 302 happy_hour = HappyHour.objects.first() assert happy_hour is not None assert happy_hour.shops.first() == shop assert happy_hour.time_ranges.count() == 2 # Since happy hour starts and ends on different day assert happy_hour.time_ranges.filter(weekday=1).exists() assert happy_hour.time_ranges.filter(weekday=1, from_hour=from_hour, to_hour=datetime.time(23, 59)).exists() assert happy_hour.time_ranges.filter(weekday=2, from_hour=datetime.time(0), to_hour=to_hour).exists() _assert_view_get(rf, happy_hour, shop, staff_user) # Viewing the edit should also still work
def test_list_view_with_multiple_suppliers(rf, admin_user): shop = factories.get_default_shop() product = factories.create_product(sku="test", shop=shop) shop_product = product.get_shop_instance(shop) shop_product.primary_category = factories.get_default_category() shop_product.save() shop_product.categories.add(shop_product.primary_category) # Also one product with supplier supplier = factories.get_default_supplier() product2 = factories.create_product(sku="test2", shop=shop, supplier=supplier) shop_product2 = product2.get_shop_instance(shop) shop_product2.primary_category = factories.get_default_category() shop_product2.save() shop_product2.categories.add(shop_product.primary_category) with override_settings(E-Commerce_ENABLE_MULTIPLE_SUPPLIERS=True): view = load("E-Commerce.admin.modules.products.views:ProductListView").as_view() request = apply_request_middleware(rf.get("/", { "jq": json.dumps({"perPage": 100, "page": 1}) }), user=admin_user) response = view(request) assert 200 <= response.status_code < 300 data = json.loads(response.content.decode("utf-8")) product_data = [item for item in data["items"] if item["_id"] == shop_product.pk][0] assert product_data["primary_category"] == factories.get_default_category().name assert product_data["categories"] == factories.get_default_category().name assert product_data["categories"] == factories.get_default_category().name assert product_data["suppliers"] == "" product_data2 = [item for item in data["items"] if item["_id"] == shop_product2.pk][0] assert product_data2["suppliers"] == factories.get_default_supplier().name
def test_notification(admin_user, specific_user): AddNotification(make_bind_data( variables={"priority": "priority"}, constants={ "message": "Hi {{ name }}!", "message_identifier": "hi mom", "url": "http://burymewithmymoney.com/", "recipient_type": (RecipientType.SPECIFIC_USER if specific_user else RecipientType.ADMINS), "recipient": (admin_user if specific_user else None), "priority": Priority.CRITICAL } )).execute(Context.from_variables(name="Justin Case", shop=factories.get_default_shop())) notif = Notification.objects.last() assert isinstance(notif, Notification) if specific_user: assert notif.recipient == admin_user assert Notification.objects.unread_for_user(admin_user).get(pk=notif.pk) assert notif.identifier == "hi mom" assert notif.message == "Hi Justin Case!" assert notif.priority == Priority.CRITICAL assert notif.url == "http://burymewithmymoney.com/" with pytest.raises(ValueError): notif.url = "http://www.theuselessweb.com/" assert not notif.is_read notif.mark_read(admin_user) # Once, for setting notif.mark_read(admin_user) # Twice, for branch checking assert notif.marked_read_by == admin_user assert very_recently(notif.marked_read_on)
def test_log_entry_on_unloggable_object(target_obj): event = get_initialized_test_event() event.variable_values["order"] = target_obj # invalidate log target _before_ creating context ctx = Context.from_event(event, shop=factories.get_default_shop()) n_log_entries = ctx.log_entry_queryset.count() ctx.add_log_entry_on_log_target("blap", "blorr") assert ctx.log_entry_queryset.count() == n_log_entries # couldn't add :(
def test_get_items_from_obj_context(): shop = factories.get_default_shop() customer = factories.create_random_person() contact_group = factories.create_random_contact_group() contact_group.members.add(customer) context = Context() context.customer = customer items = _get_items_from_context(context) groups = context_cache._get_val(customer.groups.all()) # check whether items were cached assert cache.get("_ctx_cache:customer_%d" % customer.pk) == groups assert context._ctx_cache_customer == groups assert items["customer_groups"] == groups assert "customer" not in items get_val_mock = mock.Mock(wraps=context_cache._get_val) with mock.patch.object(context_cache, "_get_val", new=get_val_mock): # get items again from the context, it shouldn't invoke _gel_val again for the customer get_val_mock.assert_not_called() items = _get_items_from_context(context) get_val_mock.assert_not_called() assert items["customer_groups"] == groups assert "customer" not in items
def test_create_new_basket(admin_user): with override_settings(**REQUIRED_SETTINGS): shop = factories.get_default_shop() shop2 = create_shop("foobar") client = _get_client(admin_user) response = client.post("/api/E-Commerce/basket/new/", { "shop": shop2.pk }) assert response.status_code == status.HTTP_201_CREATED basket_data = json.loads(response.content.decode("utf-8")) basket = Basket.objects.first() assert basket.key == basket_data['uuid'].split("-")[1] assert basket.shop == shop2 admin_contact = get_person_contact(admin_user) assert basket.customer == admin_contact assert basket.orderer == admin_contact assert basket.creator == admin_user # invalid shop response = client.post("/api/E-Commerce/basket/new/", data={"shop": 1000}) assert response.status_code == status.HTTP_400_BAD_REQUEST # no shop in multishop mode response = client.post("/api/E-Commerce/basket/new/") assert response.status_code == status.HTTP_400_BAD_REQUEST # no shop in single shop mode with override_settings(E-Commerce_ENABLE_MULTIPLE_SHOPS=False): response = client.post("/api/E-Commerce/basket/new/") assert response.status_code == status.HTTP_201_CREATED basket_data = json.loads(response.content.decode("utf-8")) basket = Basket.objects.all()[1] assert basket.key == basket_data['uuid'].split("-")[1] assert basket.shop == shop assert basket.customer == admin_contact assert basket.orderer == admin_contact assert basket.creator == admin_user person = factories.create_random_person() response = client.post("/api/E-Commerce/basket/new/", data={"customer": person.pk}) assert response.status_code == status.HTTP_201_CREATED basket_data = json.loads(response.content.decode("utf-8")) basket = Basket.objects.all()[2] assert basket.key == basket_data['uuid'].split("-")[1] assert basket.shop == shop assert basket.creator == admin_user assert basket.customer.pk == person.pk assert basket.orderer.pk == person.pk assert basket.creator.pk == admin_user.pk # Try to fetch the basket as the customer user = factories.UserFactory() person.user = user person.save() response = client.get("/api/E-Commerce/basket/{}/".format(basket_data['uuid'])) assert response.status_code == 200 customer_basket_data = json.loads(response.content.decode("utf-8")) assert basket.key == customer_basket_data['key'] # Still same basket as before assert customer_basket_data['customer']['id'] == person.pk # Still same customer as before
def get_context(rf, customer=None): request = rf.get("/") request.shop = factories.get_default_shop() apply_request_middleware(request) if customer: request.customer = customer return get_jinja_context(**{"request": request})
def test_edit_object_view(rf, admin_user, creator_fn): shop = factories.get_default_shop() view = EditObjectView.as_view() object_instance = creator_fn() model = ".".join(ContentType.objects.get_for_model(object_instance).natural_key()) # correct shop response = _get_edit_object_view(rf, view, model, object_instance.id, admin_user, shop) assert response.status_code == 302 urls = [] try: urls.append(get_model_url(object_instance, kind="edit", user=admin_user, shop=shop)) except NoModelUrl: pass try: urls.append(get_model_url(object_instance, kind="detail", user=admin_user, shop=shop)) except NoModelUrl: pass assert response.url in urls # pass the mode query parameter response = _get_edit_object_view(rf, view, model, object_instance.id, admin_user, shop, mode="test") assert response.status_code == 302 assert "mode=test" in response.url
def test_comment_visibility(admin_user): shop = factories.get_default_shop() admin_contact = get_person_contact(admin_user) staff_user = factories.create_random_user("en", is_staff=True) staff_contact = get_person_contact(staff_user) shop.staff_members.add(staff_user) normal_user = factories.create_random_user("en") normal_contact = get_person_contact(normal_user) task_type = TaskType.objects.create(name="Request", shop=shop) task = create_task(shop, admin_contact, task_type, "my task") task.comment(admin_contact, "This is only visibile for super users", TaskCommentVisibility.ADMINS_ONLY) task.comment(staff_contact, "This is only visibile for staff only", TaskCommentVisibility.STAFF_ONLY) task.comment(normal_contact, "This is visibile for everyone", TaskCommentVisibility.PUBLIC) # admin see all comments assert task.comments.for_contact(admin_contact).count() == 3 # staff see all public + staff only assert task.comments.for_contact(staff_contact).count() == 2 # normal contact see all public assert task.comments.for_contact(normal_contact).count() == 1 # anonymous contact see all public assert task.comments.for_contact(AnonymousContact()).count() == 1
def test_edit_object_view_errors(rf, admin_user): shop = factories.get_default_shop() view = EditObjectView.as_view() # missing params response = view(apply_request_middleware(rf.get(reverse("E-Commerce_admin:edit")), user=admin_user, shop=shop)) assert response.status_code == 400 assert "Invalid object" in response.content.decode("utf-8") # invalid model response = _get_edit_object_view(rf, view, ".", None, admin_user, shop) assert response.status_code == 400 assert "Invalid model" in response.content.decode("utf-8") # invalid object ID product = factories.create_product("p1", shop, factories.get_default_supplier()) model = ".".join(ContentType.objects.get_for_model(product).natural_key()) with pytest.raises(Http404) as error: _get_edit_object_view(rf, view, model, product.id + 10, admin_user, shop) assert "Object not found" in str(error) # object has no admin url from E-Commerce.core.models import ConfigurationItem config = ConfigurationItem.objects.create(shop=shop, key="test", value={"value": 123}) model = ".".join(ContentType.objects.get_for_model(config).natural_key()) with pytest.raises(Http404) as error: _get_edit_object_view(rf, view, model, config.id, admin_user, shop) assert "Object not found" in str(error)
def test_forcing_to_person_and_anonymous_contact(rf, admin_user): company_contact = get_company_contact(admin_user) assert company_contact is None shop = factories.get_default_shop() company_contact = get_company_contact_for_shop_staff(shop, admin_user) assert isinstance(company_contact, CompanyContact) assert company_contact == get_company_contact(admin_user) person_contact = get_person_contact(admin_user) assert person_contact is not None assert not person_contact.is_anonymous force_person_contact_for_user(admin_user) assert get_company_contact(admin_user) is None force_anonymous_contact_for_user(admin_user) assert get_person_contact(admin_user).is_anonymous force_person_contact_for_user(admin_user, False) assert get_company_contact(admin_user) is None # Since the person contact is still anonymous assert get_person_contact(admin_user).is_anonymous force_anonymous_contact_for_user(admin_user, False) assert company_contact == get_company_contact(admin_user) assert not get_person_contact(admin_user).is_anonymous
def test_add_product_with_extra_parent_line(rf): """ Add product to basket with extra info and parent line """ with override_settings(**CORE_BASKET_SETTINGS): shop = factories.get_default_shop() user = factories.create_random_user() product = factories.create_product("product", shop, factories.get_default_supplier(), 10) request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) cmd_response = basket_commands.handle_add(request, basket, product.id, 1, extra={"more": "stuff"}) line_id1 = cmd_response["line_id"] assert cmd_response["ok"] line1 = basket.get_basket_line(line_id1) assert line1._data["more"] == "stuff" cmd_response = basket_commands.handle_add( request, basket, product.id, 1, parent_line=line1, force_new_line=True) line_id2 = cmd_response["line_id"] assert cmd_response["ok"] line2 = basket.get_basket_line(line_id2) assert not line2._data assert line_id1 != line_id2 assert line2.parent_line.line_id == line_id1
def test_authenticate_form_without_consent_checkboxes(client): activate("en") shop = factories.get_default_shop() user = factories.create_random_user("en") user.email = "*****@*****.**" user.set_password("1234") user.save() consent_text = printable_gibberish() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.skip_consent_on_auth = True gdpr_settings.auth_consent_text = consent_text gdpr_settings.save() # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) redirect_target = "/redirect-success/" client = SmartClient() login_url = reverse("E-Commerce:login") response = client.get(login_url) soup = BeautifulSoup(response.content) login_form = soup.find("form", {"action": "/login/"}) assert len(login_form.findAll("input")) == 4 assert consent_text in login_form.text # user didn't check the privacy policy agreement response = client.post(login_url, data={ "username": user.email, "password": "******", REDIRECT_FIELD_NAME: redirect_target }) assert response.status_code == 302
def test_class_refunded(): shop = factories.get_default_shop() supplier = factories.get_default_supplier() customer = factories.create_random_person("en") OrderStatusManager().ensure_default_statuses() product = factories.create_product("p", shop, supplier, 1.0) order = factories.create_order_with_product(product, supplier, 1, 1, shop=shop) # make sure to have some script enabled Script.objects.create(shop=shop, event_identifier="order_status_changed", name="Script", enabled=True) def get_mocked_cls(): return mock.MagicMock(identifier="order_status_changed") with mock.patch("E-Commerce.front.notify_events.OrderStatusChanged", new_callable=get_mocked_cls) as mocked: order.status = OrderStatus.objects.get_default_processing() order.save() mocked.assert_called() order.refresh_from_db() assert mocked.call_args.kwargs["order"] == order assert mocked.call_args.kwargs["old_status"] == OrderStatus.objects.get_default_initial() assert mocked.call_args.kwargs["new_status"] == OrderStatus.objects.get_default_processing() assert order.status == OrderStatus.objects.get_default_processing() # nothing changes with mock.patch("E-Commerce.front.notify_events.OrderStatusChanged", new_callable=get_mocked_cls) as mocked: order.status = OrderStatus.objects.get_default_processing() order.save() mocked.assert_not_called()
def test_field_provider(rf, admin_user): activate("en") shop = factories.get_default_shop() gdpr_settings = GDPRSettings.get_for_shop(shop) gdpr_settings.enabled = True gdpr_settings.save() # create privacy policy GDPR document privacy_policy = ensure_gdpr_privacy_policy(shop) page_consent_key = "accept_%d" % privacy_policy.pk request = apply_request_middleware(rf.post("/"), shop=shop, user=admin_user) field_provider = GDPRFieldProvider() # call twice.. the field should be there while the user hasn't consented to the page for test in range(2): fields = field_provider.get_fields(request=request) assert page_consent_key in [f.name for f in fields] # consent to the page, the field shouldn't be there create_user_consent_for_all_documents(shop, admin_user) fields = field_provider.get_fields(request=request) assert page_consent_key not in [f.name for f in fields] # change the document version - field must be there again privacy_policy.save() fields = field_provider.get_fields(request=request) assert page_consent_key in [f.name for f in fields] # check if the field is shown for anonymous request = apply_request_middleware(rf.post("/"), shop=shop, user=AnonymousUser()) fields = field_provider.get_fields(request=request) assert page_consent_key in [f.name for f in fields]
def test_discounted_price(rf): shop = factories.get_default_shop() supplier = factories.get_default_supplier() request = rf.get("/") request.shop = shop apply_request_middleware(request) assert request.shop == shop original_price = 10 product = factories.create_product("test1", shop=shop, supplier=supplier, default_price=original_price) shop_product = product.get_shop_instance(shop) # Set discount with discount amount for $2 discount_amount = 2 discount = Discount.objects.create( active=True, product=product, supplier=supplier, discount_amount_value=discount_amount) discount.shops = [shop] # Even though the supplier is matching with the product there is no discount # since the supplier is not in pricing context. assert not hasattr(request, "supplier") assert supplier in shop_product.suppliers.all() assert product.get_price_info(request).price == request.shop.create_price(10) setattr(request, "supplier", supplier) assert product.get_price_info(request).price == request.shop.create_price(8) # No discount once we change the discount supplier new_supplier = Supplier.objects.create(identifier="*") discount.supplier = new_supplier discount.save() assert product.get_price_info(request).price == request.shop.create_price(10)
def test_category_tour(browser, admin_user, live_server, settings): shop = factories.get_default_shop() shop2 = factories.get_shop(identifier="shop2") admin_user_2 = factories.create_random_user(is_staff=True, is_superuser=True) admin_user_2.set_password("password") admin_user_2.save() shop.staff_members.add(admin_user) shop.staff_members.add(admin_user_2) for user in [admin_user, admin_user_2]: initialize_admin_browser_test(browser, live_server, settings, username=user.username, tour_complete=False) wait_until_condition(browser, lambda x: x.is_text_present("Welcome!")) browser.visit(live_server + "/sa/categories/new") wait_until_condition(browser, lambda x: x.is_text_present("Add a new product category"), timeout=30) wait_until_condition(browser, lambda x: x.is_element_present_by_css(".shepherd-button.btn-primary")) click_element(browser, ".shepherd-button.btn-primary") wait_until_condition(browser, lambda x: not x.is_element_present_by_css(".shepherd-button")) wait_until_condition(browser, lambda x: is_tour_complete(shop, "category", user)) # check whether the tour is shown again browser.visit(live_server + "/sa/categories/new") wait_until_condition(browser, lambda x: not x.is_text_present("Add a new product category")) browser.visit(live_server + "/logout") browser.visit(live_server + "/sa") assert is_tour_complete(shop2, "category", user) is False
def test_product_tour(browser, admin_user, live_server, settings): shop = factories.get_default_shop() shop2 = factories.get_shop(identifier="shop2") admin_user_2 = factories.create_random_user(is_staff=True, is_superuser=True) admin_user_2.set_password("password") admin_user_2.save() product = factories.get_default_product() shop_product = product.get_shop_instance(shop) shop.staff_members.add(admin_user) shop.staff_members.add(admin_user_2) for user in [admin_user, admin_user_2]: initialize_admin_browser_test(browser, live_server, settings, username=user.username, tour_complete=False) wait_until_condition(browser, lambda x: x.is_text_present("Welcome!")) browser.visit(live_server + "/sa/products/%d/" % shop_product.pk) wait_until_condition(browser, lambda x: x.is_text_present(shop_product.product.name)) # as this is added through javascript, add an extra timeout wait_until_condition(browser, lambda x: x.is_text_present("You are adding a product."), timeout=30) wait_until_condition(browser, lambda x: x.is_element_present_by_css(".shepherd-button.btn-primary")) click_element(browser, ".shepherd-button.btn-primary") category_targets = [ "a.shepherd-enabled[href='#basic-information-section']", "a.shepherd-enabled[href='#additional-details-section']", "a.shepherd-enabled[href='#manufacturer-section']", "a.shepherd-enabled[href*='-additional-section']", "a.shepherd-enabled[href='#product-media-section']", "a.shepherd-enabled[href='#product-images-section']", "a.shepherd-enabled[href='#contact-group-pricing-section']", "a.shepherd-enabled[href='#contact-group-discount-section']" ] # Scroll top before starting to click. For some reason the first # item is not found without this. For Firefox or Chrome the browser # does not do any extra scroll which could hide the first item. # Steps are scrollTo false on purpose since the scrollTo true is the # config which does not work in real world. browser.execute_script("window.scrollTo(0,0)") for target in category_targets: try: wait_until_condition(browser, lambda x: x.is_element_present_by_css(target)) browser.find_by_css(".shepherd-button.btn-primary").last.click() except ElementNotInteractableException: move_to_element(browser, ".shepherd-button.btn-primary") wait_until_condition(browser, lambda x: x.is_element_present_by_css(target)) browser.find_by_css(".shepherd-button.btn-primary").last.click() wait_until_condition(browser, lambda x: is_tour_complete(shop, "product", user)) # check whether the tour is shown again browser.visit(live_server + "/sa/products/%d/" % shop_product.pk) wait_until_condition(browser, lambda x: not x.is_text_present("You are adding a product."), timeout=20) assert is_tour_complete(shop2, "product", user) is False browser.visit(live_server + "/logout") browser.visit(live_server + "/sa")
def test_basket_with_staff_user(): with override_settings(**REQUIRED_SETTINGS): set_configuration() shop = factories.get_default_shop() staff_user = User.objects.create(username="******", is_staff=True) client = _get_client(staff_user) person = factories.create_random_person() response = client.post("/api/E-Commerce/basket/new/", data={"shop": shop.pk, "customer": person.pk}) # Only stuff linked to shop can create baskets for someone else assert response.status_code == status.HTTP_403_FORBIDDEN # Can still add personal baskets staff_person = get_person_contact(staff_user) response = client.post( "/api/E-Commerce/basket/new/", data={"shop": shop.pk, "customer": staff_person.pk}) assert response.status_code == status.HTTP_201_CREATED basket_data = json.loads(response.content.decode("utf-8")) basket = Basket.objects.filter(key=basket_data["uuid"].split("-")[1]).first() assert basket.shop == shop assert basket.creator == staff_user assert basket.customer.pk == staff_person.pk response = client.get("/api/E-Commerce/basket/{}/".format(basket_data["uuid"])) assert response.status_code == 200 basket_uuid = basket_data["uuid"] assert basket_data['customer']['id'] == staff_person.pk assert basket_data['customer']['user'] == staff_user.pk # retrieve the basket response = client.get("/api/E-Commerce/basket/{}/".format(basket_uuid)) basket_data = json.loads(response.content.decode("utf-8")) assert basket_data['customer']['id'] == staff_person.pk assert basket_data['customer']['user'] == staff_user.pk # Ok let's link the staff member to the shop and # the basket create for random person should work shop.staff_members.add(staff_user) response = client.post( "/api/E-Commerce/basket/new/", data={"shop": shop.pk, "customer": person.pk}) assert response.status_code == status.HTTP_201_CREATED basket_data = json.loads(response.content.decode("utf-8")) basket = Basket.objects.filter(key=basket_data["uuid"].split("-")[1]).first() assert basket.shop == shop assert basket.creator == staff_user assert basket.customer.pk == person.pk response = client.get("/api/E-Commerce/basket/{}/".format(basket_data["uuid"])) assert response.status_code == 200 basket_uuid = basket_data["uuid"] assert basket_data['customer']['id'] == person.pk assert basket_data['customer']['user'] is None # retrieve the basket response = client.get("/api/E-Commerce/basket/{}/".format(basket_uuid)) basket_data = json.loads(response.content.decode("utf-8")) assert basket_data['customer']['id'] == person.pk assert basket_data['customer']['user'] is None