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_product_campaigns_section_no_shop_product(rf, admin_user): shop = factories.get_default_shop() supplier = factories.get_default_supplier() request = apply_request_middleware(rf.get("/"), user=admin_user) request.shop = shop context = ProductCampaignsSection.get_context_data(factories.create_product("test1"), request) assert not context context = ProductCampaignsSection.get_context_data(factories.create_product("test2", shop=shop), request) assert context[shop]["basket_campaigns"].count() == 0
def test_supplier_filter_get_fields(rf): shop = factories.get_default_shop() request = apply_request_middleware(rf.get("/")) category = factories.get_default_category() supplier = Supplier.objects.create(name="Mike Inc") supplier.shops.add(shop) assert SupplierProductListFilter().get_fields(request, None) is None product = factories.create_product("sku", shop=shop) shop_product = product.get_shop_instance(shop=shop) shop_product.primary_category = category shop_product.save() assert SupplierProductListFilter().get_fields(request, category) is None # Now once we link manufacturer to product we should get # form field for manufacturer shop_product.suppliers.add(supplier) form_field = SupplierProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert form_field.label == "Suppliers" assert len(form_field.widget.choices) == 1 # Add second supplier for new product supplier2 = Supplier.objects.create(name="K Inc") supplier2.shops.add(shop) new_product = factories.create_product("sku1", shop=shop) new_shop_product = new_product.get_shop_instance(shop=shop) new_shop_product.suppliers.add(supplier2) # Still one with category since shop product not linked to category form_field = SupplierProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert len(form_field.widget.choices) == 1 # Without category we get two results form_field = SupplierProductListFilter().get_fields(request, None)[0][1] assert form_field is not None assert len(form_field.widget.choices) == 2 new_shop_product.categories.add(category) # primary category shouldn't be required # Now with or without category we get 2 results form_field = SupplierProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert len(form_field.widget.choices) == 2 form_field = SupplierProductListFilter().get_fields(request, None)[0][1] assert form_field is not None assert len(form_field.widget.choices) == 2
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_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_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_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_contact_group_discount(rf): default_price = 10 request, product = _init_test_for_product(rf, default_price) # Just to demonstrate that discounts can be created without products # and categories. This contact group gets $2 off from every product. product_discount_amount = 2 random_company = factories.create_random_company() contact_group = factories.get_default_customer_group() random_company.groups.add(contact_group) request.customer = random_company discount = Discount.objects.create( active=True, contact_group=contact_group, discount_amount_value=product_discount_amount) discount.shops.add(request.shop) assert product.get_price_info(request).price == request.shop.create_price(default_price - product_discount_amount) new_product_price = 7 new_product = factories.create_product("test1", shop=request.shop, default_price=new_product_price) assert new_product.get_price_info(request).price == ( request.shop.create_price(new_product_price - product_discount_amount)) # Changing the request customer drops the $2 discount request.customer = factories.create_random_company() assert not request.customer.groups.filter(id=contact_group.pk).exists() assert product.get_price_info(request).price == request.shop.create_price(default_price) assert new_product.get_price_info(request).price == request.shop.create_price(new_product_price)
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_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 _create_order(shop, customer): p1 = factories.create_product("test", shop=shop, supplier=factories.get_default_supplier()) order = factories.create_order_with_product(factories.get_default_product(), factories.get_default_supplier(), 2, 10, shop=shop) factories.add_product_to_order(order, factories.get_default_supplier(), p1, 2, 5) order.customer = customer order.save() return order
def test_category_filter(): shop = factories.get_default_shop() category1 = Category.objects.create(name="Category 1") category1.shops.add(shop) product1 = factories.create_product("p1", shop, factories.get_default_supplier(), "10") shop_product1 = product1.get_shop_instance(shop) shop_product1.categories.add(category1) category2 = Category.objects.create(name="Category 2") category2.shops.add(shop) product2 = factories.create_product("p2", shop, factories.get_default_supplier(), "20") shop_product2 = product2.get_shop_instance(shop) shop_product2.categories.add(category2) client = SmartClient() config = {"filter_products_by_category": True} set_configuration(shop=shop, data=config) url = reverse('E-Commerce:all-categories') # 1) go to all categories view and list products # no filters being applied should list all products response, soup = client.response_and_soup(url) assert response.status_code == 200 assert soup.find(id="product-%d" % product1.id) assert soup.find(id="product-%d" % product2.id) # 2) filter by category2 id only response, soup = client.response_and_soup("{}?categories={}".format(url, category2.pk)) assert response.status_code == 200 assert not soup.find(id="product-%d" % product1.id) assert soup.find(id="product-%d" % product2.id) # 3) filter by category1 and category2 id response, soup = client.response_and_soup("{}?categories={},{}".format(url, category1.pk, category2.pk)) assert response.status_code == 200 assert soup.find(id="product-%d" % product1.id) assert soup.find(id="product-%d" % product2.id) # 4) filter by blank value, it shouldn't break response, soup = client.response_and_soup("{}?categories=".format(url)) assert response.status_code == 200 assert soup.find(id="product-%d" % product1.id) assert soup.find(id="product-%d" % product2.id)
def init_test(): shop = factories.get_default_shop() product = factories.create_product("test", shop=shop, default_price=10) discount = Discount.objects.create(active=True, product=product, discounted_price_value=6) discount.shops = [shop] happy_hour = HappyHour.objects.create(name="Happy") happy_hour.shops = [shop] discount.happy_hours = [happy_hour] return happy_hour
def test_product_detail_view(): vc = _get_basic_view_config(view_name="ProductDetailView") product = factories.create_product("test", shop=factories.get_default_shop(), name="Test product name") product2 = factories.create_product("test2", shop=factories.get_default_shop(), name="Test product name 2") placeholder_name = "product_extra_1" context = {"product": product} layout = vc.get_placeholder_layout(ProductLayout, placeholder_name, context=context) plugin_text = printable_gibberish() _add_plugin_and_test_save(vc, layout, placeholder_name, context, plugin_text) # Also let's confirm that the plugin visibility works with smart client c = SmartClient() soup = c.soup(reverse("E-Commerce:product", kwargs={"pk": product.id, "slug": product.slug})) product_details = soup.find("div", {"class": "product-basic-details"}) assert plugin_text in product_details.text c = SmartClient() soup = c.soup(reverse("E-Commerce:product", kwargs={"pk": product2.id, "slug": product2.slug})) product_details = soup.find("div", {"class": "product-basic-details"}) assert plugin_text not in product_details.text
def _init_test_for_product(rf, default_price): shop = factories.get_default_shop() supplier = factories.get_default_supplier() request = rf.get("/") request.shop = shop apply_request_middleware(request) assert request.shop == shop product = factories.create_product("test", shop=shop, supplier=supplier, default_price=default_price) assert product.get_price_info(request).price == shop.create_price(default_price) return request, product
def test_price_info_cache_bump(rf): initial_price = 10 shop = factories.get_default_shop() tax = factories.get_default_tax() tax_class = factories.get_default_tax_class() product = factories.create_product( "product", shop=shop, supplier=factories.get_default_supplier(), default_price=initial_price ) request = apply_request_middleware(rf.get("/")) def assert_cache_product(): cache_price_info(request, product, 1, product.get_price_info(request)) assert get_cached_price_info(request, product, 1).price == shop.create_price(initial_price) def assert_nothing_is_cached(): # nothing is cached assert get_cached_price_info(request, product, 1) is None # cache the item assert_nothing_is_cached() assert_cache_product() # cache bumped - the cache should be dropped - then, cache again tax.save() assert_nothing_is_cached() assert_cache_product() # cache bumped - the cache should be dropped - then, cache again tax_class.save() assert_nothing_is_cached() assert_cache_product() # cache bumped - the cache should be dropped - then, cache again product.save() assert_nothing_is_cached() assert_cache_product() shop_product = product.get_shop_instance(shop) # cache bumped - the cache should be dropped - then, cache again shop_product.save() assert_nothing_is_cached() assert_cache_product() category = factories.get_default_category() # cache bumped - the cache should be dropped - then, cache again shop_product.categories.add(category) assert_nothing_is_cached() assert_cache_product()
def test_default_layout(): vc = _get_basic_view_config() product = factories.create_product("test", name="Test product name") category = factories.get_default_category() placeholder_name = "wildhorse" context = {"request": get_request(), "product": product, "category": category} layout = vc.get_placeholder_layout(Layout, placeholder_name) assert isinstance(layout, Layout) assert layout.get_help_text({}) == layout.get_help_text(context) _add_plugin_and_test_save(vc, layout, placeholder_name, context)
def test_edit_object_view_no_permissions(rf): user = factories.create_random_user("en", is_staff=True) shop = factories.get_default_shop() shop.staff_members.add(user) view = EditObjectView.as_view() product = factories.create_product("p1", shop, factories.get_default_supplier()) model = ".".join(ContentType.objects.get_for_model(product).natural_key()) # no permission with pytest.raises(Problem) as error: _get_edit_object_view(rf, view, model, product.id, user, shop) assert "You do not have the required permission" in str(error)
def test_product_layout(): vc = _get_basic_view_config() product = factories.create_product("test", shop=factories.get_default_shop(), name="Test product name") placeholder_name = "wow" # Context doesn't validate with the product layout assert vc.get_placeholder_layout(ProductLayout, placeholder_name) is None context = {"product": product} layout = vc.get_placeholder_layout(ProductLayout, placeholder_name, context=context) assert isinstance(layout, ProductLayout) assert layout.get_help_text({}) == "" # Invalid context for help text assert product.name in layout.get_help_text(context) _assert_empty_layout(layout, placeholder_name) _add_plugin_and_test_save(vc, layout, placeholder_name, context) # Make sure layout only available for this one product new_product = factories.create_product("new_test") context = {"product": new_product} layout = vc.get_placeholder_layout(ProductLayout, placeholder_name, context=context) _assert_empty_layout(layout, placeholder_name)
def test_serialize_data(): """ Test contact dashboard views """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") user = factories.create_random_user("en") user.set_password("1234") user.save() customer.user = user customer.default_billing_address = factories.create_random_address() customer.default_shipping_address = factories.create_random_address() customer.save() company = factories.create_random_company() company.default_billing_address = factories.create_random_address() company.default_shipping_address = factories.create_random_address() company.save() company.members.add(customer) product = factories.create_product("p1", shop, factories.get_default_supplier()) for basket_customer in [customer, company]: [factories.create_random_order(basket_customer, [product]) for order in range(3)] client = SmartClient() client.login(username=user.username, password="******") response = client.get(reverse("E-Commerce:gdpr_customer_dashboard")) assert response.status_code == 200 assert "My Data" in response.content.decode("utf-8") response = client.post(reverse("E-Commerce:gdpr_download_data")) assert response._headers["content-disposition"][0] == "Content-Disposition" assert response.status_code == 200 from E-Commerce.tasks.models import Task, TaskType from E-Commerce.gdpr.models import GDPR_ANONYMIZE_TASK_TYPE_IDENTIFIER response = client.post(reverse("E-Commerce:gdpr_anonymize_account")) assert response.status_code == 302 assert response.url.endswith(reverse("E-Commerce:index")) task_type = TaskType.objects.get(identifier=GDPR_ANONYMIZE_TASK_TYPE_IDENTIFIER, shop=shop) assert Task.objects.get(type=task_type, shop=shop) user.refresh_from_db() assert user.is_active is False refreshed_customer = PersonContact.objects.get(id=customer.id) assert refreshed_customer.is_active is False assert refreshed_customer.name == customer.name # nothing changed yet
def test_add_product(rf): """ Add product to basket """ 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) assert cmd_response["ok"] assert cmd_response["line_id"] assert cmd_response["added"] == 1 assert len(basket.get_lines()) == 1
def _init_test_for_product_without_basket(rf, default_price): shop = factories.get_default_shop() supplier = factories.get_default_supplier() random_customer = factories.create_random_person() request = rf.get("/") apply_request_middleware(request, shop=shop, customer=random_customer) assert request.shop == shop assert request.customer == random_customer sku = "test" product = Product.objects.filter(sku=sku).first() if not product: product = factories.create_product(sku, shop=shop, supplier=supplier, default_price=default_price) assert product.get_price_info(request).price == shop.create_price(default_price) return request, product
def test_basket_with_custom_shop(rf): """ Set a different shop for basket """ with override_settings(**CORE_BASKET_SETTINGS): shop1 = factories.get_default_shop() shop2 = factories.get_shop(identifier="shop2") user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user, shop=shop1) basket_class = cached_load("E-Commerce_BASKET_CLASS_SPEC") basket = basket_class(request, "basket", shop=shop2) assert basket.shop == shop2 product_shop2 = factories.create_product("product_shop2", shop2, factories.get_default_supplier(), 10) line = basket.add_product(factories.get_default_supplier(), shop2, product_shop2, 1) assert line.shop == shop2
def test_discount_amount(rf): shop = factories.get_default_shop() request = rf.get("/") request.shop = shop apply_request_middleware(request) assert request.shop == shop original_price = 10 product = factories.create_product("test1", shop=shop, default_price=original_price) # Set discount percentage to 20% which means $2 discount_percentage = 0.20 discount = Discount.objects.create(active=True, product=product, discount_percentage=discount_percentage) discount.shops = [shop] assert product.get_price_info(request).price == request.shop.create_price(8) # Let's set discounted price to let's say $5 discounted_price = 5 discount = Discount.objects.create(active=True, product=product, discounted_price_value=discounted_price) discount.shops = [shop] assert product.get_price_info(request).price == request.shop.create_price(5) # All discount amount values up to $5 shouldn't change the product price for x in range(0, 5): discount_amount = decimal.Decimal(random.randrange(1, 501))/100 discount = Discount.objects.create(active=True, product=product, discount_amount_value=discount_amount) discount.shops = [shop] assert product.get_price_info(request).price == request.shop.create_price(5) # Finally let's set discount amount value higher than all other discounts discount_amount = decimal.Decimal(random.randrange(500, 1000))/100 discount = Discount.objects.create(active=True, product=product, discount_amount_value=discount_amount) discount.shops = [shop] assert product.get_price_info(request).price == request.shop.create_price(original_price - discount_amount) # Let's make sure price doesn't go below zero discount_amount = decimal.Decimal(random.randrange(1000, 25000))/100 discount = Discount.objects.create(active=True, product=product, discount_amount_value=discount_amount) discount.shops = [shop] assert product.get_price_info(request).price == request.shop.create_price(0) # Finally let's make sure the minimum price value for shop product is honored shop_product = product.get_shop_instance(shop) min_price = decimal.Decimal(random.randrange(1, 501))/100 shop_product.minimum_price_value = min_price shop_product.save() assert product.get_price_info(request).price == request.shop.create_price(min_price)
def test_suppliers_filter_get_fields(rf): cache.clear() shop = factories.get_default_shop() request = apply_request_middleware(rf.get("/")) assert SupplierProductListFilter().get_fields(request, None) is None supplier = Supplier.objects.create(name="Favorite brands dot com") supplier.shops.add(shop) assert Supplier.objects.enabled().exists() assert SupplierProductListFilter().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 SupplierProductListFilter().get_fields(request, category) is None # Now once we link supplier to product we should get # form field for manufacturer shop_product.suppliers.add(supplier) form_field = SupplierProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert form_field.label == "Suppliers" with override_settings(E-Commerce_FRONT_OVERRIDE_SORTS_AND_FILTERS_LABELS_LOGIC={"supplier": "Filter by suppliers"}): form_field = SupplierProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert form_field.label == "Filter by suppliers" assert isinstance(form_field, forms.ModelChoiceField) configuration = get_configuration(shop, category) configuration.update({ SupplierProductListFilter.enable_multiselect_key: True }) set_configuration(shop, category, configuration) form_field = SupplierProductListFilter().get_fields(request, category)[0][1] assert form_field is not None assert form_field.label == "Filter by suppliers" assert isinstance(form_field, CommaSeparatedListField) cache.clear()
def test_discount_admin_edit_view(rf, staff_user, admin_user): with override_settings(E-Commerce_ENABLE_MULTIPLE_SHOPS=True): shop = factories.get_default_shop() shop.staff_members.add(staff_user) factories.get_shop(identifier="shop2") assert Shop.objects.count() == 2 # Staff user gets shop automatically product = factories.create_product("test", shop=shop) discount_percentage = 20 data = {"product": product.pk, "discount_percentage": discount_percentage} request = apply_request_middleware(rf.post("/", data=data), user=staff_user, shop=shop) set_shop(request, shop) assert request.shop == shop view_func = DiscountEditView.as_view() response = view_func(request) if hasattr(response, "render"): response.render() assert response.status_code == 302 discount1 = Discount.objects.first() assert discount1.shops.first() == shop # Test with superuser and with different shop shop2 = factories.get_shop(enabled=True) request = apply_request_middleware(rf.post("/", data=data), user=admin_user, shop=shop2) set_shop(request, shop2) view_func = DiscountEditView.as_view() response = view_func(request) assert response.status_code == 302 assert Discount.objects.count() == 2 discount2 = Discount.objects.exclude(id=discount1.pk).first() assert discount1 != discount2 assert discount2.shops.count() == 1 assert discount2.shops.filter(id=shop2.pk).exists() # Staff user can only view discount1 since that has the right shop _assert_view_get(rf, discount1, shop, staff_user) _assert_view_get(rf, discount2, shop, staff_user, True) # Superuser can see both if needed, but only when right shop is active _assert_view_get(rf, discount1, shop, admin_user) _assert_view_get(rf, discount2, shop, admin_user, True) _assert_view_get(rf, discount2, shop2, admin_user)
def test_product_campaigns_section(rf, admin_user): shop = factories.get_default_shop() supplier = factories.get_default_supplier() product = factories.create_product("test", shop=shop, supplier=supplier, default_price=10) campaign1 = _create_active_campaign(shop, supplier, product) campaign2 = _create_active_campaign(shop, None, product) shop_staff_user = factories.create_random_user(is_staff=True) shop.staff_members.add(shop_staff_user) supplier_staff_user = factories.create_random_user(username=supplier.identifier, is_staff=True) shop.staff_members.add(supplier_staff_user) supplier_provider = "E-Commerce.testing.supplier_provider.UsernameSupplierProvider" with override_settings(E-Commerce_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider): request = apply_request_middleware(rf.get("/"), user=admin_user) request.shop = shop assert get_supplier(request) is None context = ProductCampaignsSection.get_context_data(product, request) assert context[shop]["basket_campaigns"].count() == 2 request = apply_request_middleware(rf.get("/"), user=shop_staff_user) request.shop = shop assert get_supplier(request) is None context = ProductCampaignsSection.get_context_data(product, request) assert context[shop]["basket_campaigns"].count() == 2 request = apply_request_middleware(rf.get("/"), user=supplier_staff_user) request.shop = shop assert get_supplier(request) == supplier context = ProductCampaignsSection.get_context_data(product, request) assert context[shop]["basket_campaigns"].count() == 1 campaign1.supplier = None campaign1.save() context = ProductCampaignsSection.get_context_data(product, request) assert context[shop]["basket_campaigns"].count() == 0 BasketCampaign.objects.update(supplier=supplier) context = ProductCampaignsSection.get_context_data(product, request) assert context[shop]["basket_campaigns"].count() == 2
def test_product_detail(client): shop = factories.get_default_shop() product = factories.create_product("sku", shop=shop, default_price=30) shop_product = product.get_shop_instance(shop) # Activate show supplier info for front assert ThemeSettings.objects.count() == 1 theme_settings = ThemeSettings.objects.first() theme_settings.update_settings({"show_supplier_info": True}) 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): # Ok so cheapest price should be default supplier expected_supplier = shop_product.get_supplier() assert expected_supplier.name == "Simon Inc" with override_current_theme_class(ClassicGrayTheme, shop): # Ensure settings is refreshed from DB soup = _get_product_detail_soup(client, product) _assert_supplier_subtitle(soup, expected_supplier) _assert_add_to_basket_form(soup, expected_supplier, 10) # Bonus! Let's say Johnny gets mad and starts to supply this product for 5 euros johnny_the_supplier = Supplier.objects.filter(name="Johnny Inc").first() SupplierPrice.objects.filter( supplier=johnny_the_supplier, shop=shop, product=product ).update(amount_value=5) # This means that product detail get new default supplier and new price assert shop_product.get_supplier() == johnny_the_supplier soup = _get_product_detail_soup(client, product) _assert_supplier_subtitle(soup, johnny_the_supplier) _assert_add_to_basket_form(soup, johnny_the_supplier, 5)
def test_gdpr_admin_download_data(client, admin_user): """ Test that admin user can download customer data """ activate("en") shop = factories.get_default_shop() customer = factories.create_random_person("en") product = factories.create_product("p1", shop, factories.get_default_supplier()) [factories.create_random_order(customer, [product]) for order in range(3)] client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_download_url = reverse("E-Commerce_admin:gdpr.download_data", kwargs=dict(pk=customer.pk)) response = client.post(admin_download_url) assert response.status_code == 200 assert response._headers["content-disposition"][0] == "Content-Disposition" assert response._headers["content-disposition"][1].startswith("attachment; filename=user_data_")
def test_supplier_product_detail(client): shop = factories.get_default_shop() product = factories.create_product("sku", shop=shop, default_price=30) shop_product = product.get_shop_instance(shop) # Activate show supplier info for front assert ThemeSettings.objects.count() == 1 theme_settings = ThemeSettings.objects.first() theme_settings.update_settings({"show_supplier_info": True}) supplier_data = [ ("Johnny Inc", 30), ("Mike Inc", 20), ("Simon Inc", 10), ] for name, product_price in supplier_data: supplier = Supplier.objects.create(name=name) supplier.shops.add(shop) 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): # Ok so cheapest price should be default supplier expected_supplier = shop_product.get_supplier() assert expected_supplier.name == "Simon Inc" with override_current_theme_class(ClassicGrayTheme, shop): # Ensure settings is refreshed from DB johnny = Supplier.objects.filter(name="Johnny Inc").first() soup = _get_supplier_product_detail_soup(client, product, johnny) _assert_supplier_subtitle(soup, johnny) _assert_add_to_basket_form(soup, johnny, 30) mike = Supplier.objects.filter(name="Mike Inc").first() soup = _get_supplier_product_detail_soup(client, product, mike) _assert_supplier_subtitle(soup, mike) _assert_add_to_basket_form(soup, mike, 20) simon = Supplier.objects.filter(name="Simon Inc").first() soup = _get_supplier_product_detail_soup(client, product, simon) _assert_supplier_subtitle(soup, simon) _assert_add_to_basket_form(soup, simon, 10)