def test_matching_product_discount_with_contact(rf): default_price = 10 request, product = _init_test_for_product(rf, default_price) product_discount_amount = 4 discount = Discount.objects.create(active=True, product=product, 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) # Adding contact condition to the discount should make # the discount go away. random_contact = factories.create_random_person() discount.contact = random_contact discount.save() assert request.customer != random_contact assert product.get_price_info(request).price == request.shop.create_price(default_price) # Let's set the new contact as request customer and we # should get the discount back. request.customer = random_contact assert product.get_price_info(request).price == request.shop.create_price(default_price - product_discount_amount) # Another contact should still only get the price without discount another_contact = factories.create_random_person() request.customer = another_contact assert product.get_price_info(request).price == request.shop.create_price(default_price)
def test_customer_usage_limit(rf): default_price = 10 request, product = _init_test_for_product_without_basket(rf, default_price) shop = request.shop customers = [] for x in range(3): customers.append(factories.create_random_company(shop=shop)) discount_percentage = 0.20 coupon = CouponCode.objects.create(code="sUpErAle", active=True, usage_limit_customer=2) coupon.shops = [request.shop] discount = Discount.objects.create( active=True, product=product, coupon_code=coupon, discount_percentage=discount_percentage) discount.shops.add(request.shop) # Order product twice for each customer for customer in customers: for y in range(2): _create_order(request, customer, coupon, product, request.shop.create_price(8)) assert coupon.usages.count() == 6 # Each customer 2 orders # Any of the customers created shouldn't be allowed to # order more with this coupon code. for customer in customers: assert not CouponCode.is_usable(shop, coupon, customer) # New customer should still be able to order some new_customer = factories.create_random_person() assert CouponCode.is_usable(shop, coupon, new_customer) _create_order(request, new_customer, coupon, product, request.shop.create_price(8)) assert coupon.usages.count() == 7 # Set usage limit and the new customer shouldn't be able to use the code coupon.usage_limit = 7 coupon.save() assert not CouponCode.is_usable(request.shop, coupon, new_customer) _create_order(request, new_customer, coupon, product, request.shop.create_price(default_price)) assert coupon.usages.count() == 7 # One of the customer got refund refunded_customer = customers[0] order = refunded_customer.customer_orders.first() coupon_code_modifier = CouponCodeModule() coupon_code_modifier.clear_codes(order) assert coupon.usages.count() == 6 # New customer still doesn't able to create coupon new_customer = factories.create_random_person() assert CouponCode.is_usable(shop, coupon, new_customer) _create_order(request, new_customer, coupon, product, request.shop.create_price(8)) assert coupon.usages.count() == 7
def test_category_product_discount_with_contact_group(rf): default_price = 10 request, product = _init_test_for_product(rf, default_price) category = factories.get_default_category() product.get_shop_instance(request.shop).categories.add(category) product_discount_amount = 4 discount = Discount.objects.create(active=True, category=category, 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) # Adding contact group limitation to the discount should # make the discount go away contact_group = factories.get_default_customer_group() discount.contact_group = contact_group discount.save() assert product.get_price_info(request).price == request.shop.create_price(default_price) # Let's set contact for request with the group created # and let's see the discount coming back random_contact = factories.create_random_person() request.customer = random_contact assert product.get_price_info(request).price == request.shop.create_price(default_price) random_contact.groups.add(contact_group) assert request.customer == random_contact assert product.get_price_info(request).price == request.shop.create_price(default_price - product_discount_amount)
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 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_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_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_person_contact_layout(): vc = _get_basic_view_config() person = factories.create_random_person() placeholder_name = "kissa" request = get_request() request.customer = person context = {"request": request} layout = vc.get_placeholder_layout(PersonContactLayout, placeholder_name, context=context) assert isinstance(layout, PersonContactLayout) help_text = layout.get_help_text({}) # Same help text with or without the context assert layout.get_help_text(context) == help_text # Invalid contexts for anon and company layouts assert vc.get_placeholder_layout(AnonymousContactLayout, placeholder_name, context=context) is None assert vc.get_placeholder_layout(CompanyContactLayout, placeholder_name, context=context) is None # Valid contexts for contact layout assert vc.get_placeholder_layout(ContactLayout, placeholder_name, context=context) is not None _add_plugin_and_test_save(vc, layout, placeholder_name, context) # Ok here we want to check that the plugin doesn't end up to the # contact placeholders contact_layout = vc.get_placeholder_layout(ContactLayout, placeholder_name, context=context) _assert_empty_layout(contact_layout, placeholder_name)
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
def test_basic_tasks(admin_user): shop = factories.get_default_shop() contact = factories.create_random_person(shop=shop) # task gets created text = "derpy hooves" task_type = TaskType.objects.create(name="Request", shop=shop) task = create_task(shop, contact, task_type, "my task", comment=text) assert Task.objects.count() == 1 assert TaskComment.objects.count() == 1 assert TaskComment.objects.first().author == contact assert contact.task_comments.count() == 1 assert not task.assigned_to assert task.status == TaskStatus.NEW # someone handles it admin_contact = factories.create_random_person() admin_contact.user = admin_user admin_contact.save() task.assign(admin_contact) task.refresh_from_db() assert task.assigned_to == admin_contact assert task.status == TaskStatus.IN_PROGRESS comment_text = "this being handled now" task.comment(admin_contact, comment_text) task.refresh_from_db() assert task.comments.count() == 2 assert task.comments.last().body == comment_text assert TaskComment.objects.count() == 2 task.set_in_progress() task.refresh_from_db() assert task.status == TaskStatus.IN_PROGRESS task.set_completed(admin_contact) task.refresh_from_db() assert task.status == TaskStatus.COMPLETED assert task.completed_on assert task.completed_by == admin_contact
def test_set_different_customer(rf): """ Set some customer to the basket that is not the request one """ with override_settings(**CORE_BASKET_SETTINGS): user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) person1 = factories.create_random_person() with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, person1) assert exc.value.code == "no_permission" assert basket.customer == get_person_contact(user) # with superuser person2 = factories.create_random_person() superuser = factories.create_random_user(is_superuser=True) request = apply_request_middleware(rf.get("/"), user=superuser) assert basket_commands.handle_set_customer(request, basket, person2)["ok"] is True assert basket.customer == person2 assert basket.orderer == person2 # with staff user not member of the shop person3 = factories.create_random_person() staff = factories.create_random_user(is_staff=True) request = apply_request_middleware(rf.get("/"), user=staff) with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, person3) assert exc.value.code == "no_permission" assert basket.customer == person2 assert basket.orderer == person2 # with staff user member of the shop person4 = factories.create_random_person() staff_member = factories.create_random_user(is_staff=True) basket.shop.staff_members.add(staff_member) request = apply_request_middleware(rf.get("/"), user=staff_member) assert basket_commands.handle_set_customer(request, basket, person4)["ok"] is True assert basket.customer == person4 assert basket.orderer == person4
def test_discount_for_person_contacts(rf): default_price = 10 request, product = _init_test_for_product(rf, default_price) assert request.customer == AnonymousContact() random_person = factories.create_random_person() person_contact_group = random_person.get_default_group() product_discount_amount = 2 discount = Discount.objects.create( active=True, contact_group=person_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) # Setting customer to request activates the discount request.customer = factories.create_random_person() assert product.get_price_info(request).price == request.shop.create_price(default_price - product_discount_amount) # Using company contact as customer means no discount request.customer = factories.create_random_company() assert product.get_price_info(request).price == request.shop.create_price(default_price)
def test_set_from_anonymous_to_customer_not_auth(rf): """ Set some customer to the basket when not authenticated """ with override_settings(**CORE_BASKET_SETTINGS): request = apply_request_middleware(rf.get("/")) basket = get_basket(request, "basket") basket.customer = AnonymousContact() customer = factories.create_random_person() assert basket_commands.handle_set_customer(request, basket, customer)["ok"] is True assert basket.customer == customer
def test_get_items_from_dict_context(): customer = factories.create_random_person() new_customer = factories.create_random_person() contact_group = factories.create_random_contact_group() contact_group.members.add(customer) context = { "customer": customer } items = _get_items_from_context(context) groups = context_cache._get_val(customer.groups.all()) assert items["customer_groups"] == groups assert "customer" not in items # check whether items were cached assert cache.get("_ctx_cache:customer_%d" % customer.pk) == groups 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() # check whether cache is bumped after changing contact get_val_mock = mock.Mock(wraps=context_cache._get_val) with mock.patch.object(context_cache, "_get_val", new=get_val_mock): customer.save() items = _get_items_from_context(context) get_val_mock.assert_called() # check whether cache is bumped after changing members of contact group get_val_mock = mock.Mock(wraps=context_cache._get_val) with mock.patch.object(context_cache, "_get_val", new=get_val_mock): items = _get_items_from_context(context) get_val_mock.assert_not_called() contact_group.members.add(new_customer) items = _get_items_from_context(context) get_val_mock.assert_called()
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_discount_for_anons(rf): default_price = 10 request, product = _init_test_for_product(rf, default_price) assert request.customer == AnonymousContact() anon_default_group = AnonymousContact().get_default_group() product_discount_amount = 2 discount = Discount.objects.create( active=True, contact_group=anon_default_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) # Setting customer to request takes out the discount request.customer = factories.create_random_person() assert product.get_price_info(request).price == request.shop.create_price(default_price)
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_set_company_customer(rf): """ Set a company as the basket customer """ with override_settings(**CORE_BASKET_SETTINGS): user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) person = factories.create_random_person() company = factories.create_random_company() # no orderer provided with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, company) assert exc.value.code == "invalid_orderer" assert basket.customer == get_person_contact(user) # orderer provided but not member of the company with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, company, person) assert exc.value.code == "orderer_not_company_member" assert basket.customer == get_person_contact(user) # orderer provided but user not member of the company company.members.add(person) with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, company, person) assert exc.value.code == "not_company_member" assert basket.customer == get_person_contact(user) # staff and admin can add any the company and orderer without being member of the company superuser = factories.create_random_user(is_superuser=True) staff = factories.create_random_user(is_staff=True) basket.shop.staff_members.add(staff) for user in [superuser, staff]: basket.customer = None basket.orderer = None request = apply_request_middleware(rf.get("/"), user=user) assert basket_commands.handle_set_customer(request, basket, company, person)["ok"] is True assert basket.customer == company assert basket.orderer == person
def test_set_from_anonymous_to_customer_auth(rf): """ Set some random customer to the basket when authenticated """ with override_settings(**CORE_BASKET_SETTINGS): user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = AnonymousContact() # can not set the customer for something different as the request customer with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, factories.create_random_person()) assert exc.value.code == "no_permission" assert basket.customer == AnonymousContact() assert basket_commands.handle_set_customer(request, basket, get_person_contact(user))["ok"] is True assert basket.customer == get_person_contact(user)
def test_anonymous_set_company_customer(rf): """ Set a company as the basket customer """ with override_settings(**CORE_BASKET_SETTINGS): user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = AnonymousContact() person = factories.create_random_person() company = factories.create_random_company() company.members.add(person) with pytest.raises(ValidationError) as exc: basket_commands.handle_set_customer(request, basket, company, person) assert exc.value.code == "not_company_member" assert basket.customer == AnonymousContact()
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_copy_order_to_basket_for_staff(admin_user): with override_settings(**REQUIRED_SETTINGS): set_configuration() shop = factories.get_default_shop() customer = factories.create_random_person() order = _create_order(shop, customer) client = get_client(admin_user) basket = factories.get_basket(shop) uuid = "%s-%s" % (shop.pk, basket.key) response = client.post( '/api/E-Commerce/basket/%s/set_customer/' % uuid, format="json", data={"customer": customer.id} ) assert response.status_code == status.HTTP_200_OK response = client.post('/api/E-Commerce/basket/%s/add_from_order/' % uuid, {"order": order.pk}) assert response.status_code == status.HTTP_404_NOT_FOUND # admin user is not staff shop.staff_members.add(admin_user) _fill_new_basket_from_order(client, basket, customer, order)
def test_gdpr_admin_anonymize(client, admin_user): """ Test that admin user can anonymize contact """ activate("en") factories.get_default_shop() person = factories.create_random_person("en") person.user = factories.create_random_user("en") person.save() client = SmartClient() admin_user.set_password("admin") admin_user.save() client.login(username=admin_user.username, password="******") admin_anonymize_url = reverse("E-Commerce_admin:gdpr.anonymize", kwargs=dict(pk=person.pk)) response = client.post(admin_anonymize_url) assert response.status_code == 302 assert response.url.endswith(reverse("E-Commerce_admin:contact.detail", kwargs=dict(pk=person.pk))) anonymized_person = PersonContact.objects.get(id=person.id) assert anonymized_person.name != person.name assert anonymized_person.user.username != person.user.username
def test_set_not_active_customer(rf): """ Set a not active customer to the basket """ with override_settings(**CORE_BASKET_SETTINGS): user = factories.create_random_user() request = apply_request_middleware(rf.get("/"), user=user) basket = get_basket(request, "basket") basket.customer = get_person_contact(user) person = factories.create_random_person() person.is_active = False person.save() company = factories.create_random_company() company.is_active = False company.save() 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" assert basket.customer == get_person_contact(user)
def _get_edit_object_view(rf, view, model_name, object_id, user, shop, mode=None): data = { "model": model_name, "id": object_id } if mode: data["mode"] = mode request = apply_request_middleware(rf.get(reverse("E-Commerce_admin:edit"), data), user=user, shop=shop) return view(request) @pytest.mark.parametrize("creator_fn", [ lambda: factories.create_product("sku", factories.get_default_shop(), factories.get_default_supplier()), lambda: factories.create_random_person(), lambda: factories.create_random_company(), lambda: factories.create_random_order(customer=factories.create_random_person(), products=[ factories.create_product("p", factories.get_default_shop(), factories.get_default_supplier()) ]), lambda: factories.create_random_user(), ]) @pytest.mark.django_db 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)
def test_catalog_campaign_sync(): shop = factories.get_default_shop() supplier = factories.get_default_supplier() default_price = 100 product1 = factories.create_product("test1", shop=shop, supplier=supplier, default_price=default_price) product2 = factories.create_product("test2", shop=shop, supplier=supplier, default_price=default_price) product3 = factories.create_product("test3", shop=shop, supplier=supplier, default_price=default_price) category = factories.get_default_category() shop_product = product1.get_shop_instance(shop) shop_product.primary_category = category shop_product.save() shop_product.categories.add(category) contact1 = factories.create_random_person() contact2 = factories.create_random_person() contact_group = factories.get_default_customer_group() contact2.groups.add(contact_group) happy_hour1_weekdays = "0,1" # Mon, Tue happy_hour1_start = datetime.time(21) happy_hour1_end = datetime.time(3) happy_hour1_condition = HourCondition.objects.create( days=happy_hour1_weekdays, hour_start=happy_hour1_start, hour_end=happy_hour1_end) happy_hour2_weekdays = "2,6" # Wed, Sun happy_hour2_start = datetime.time(14) happy_hour2_end = datetime.time(16) happy_hour2_condition = HourCondition.objects.create( days=happy_hour2_weekdays, hour_start=happy_hour2_start, hour_end=happy_hour2_end) discount_amount_value = 50 discount_percentage = decimal.Decimal("0.35") _create_catalog_campaign_for_products( shop, [product1], discount_amount_value, happy_hour1_condition) _create_catalog_campaign_for_products( shop, [product2, product3], discount_amount_value) _create_catalog_campaign_for_category( shop, category, discount_percentage) _create_catalog_campaign_for_contact( shop, product1, contact1, discount_amount_value) _create_catalog_campaign_for_contact_group( shop, [product1, product2, product3], contact_group, discount_percentage, happy_hour2_condition) call_command("import_catalog_campaigns", *[], **{}) # From first campaign we should get 1 discount with happy hour # From second campaign we should get 2 discounts # From third campaign we should get 1 discount # From fourth campaign we should get also 1 discount # From last campaign we should get 3 discounts with happy hour assert Discount.objects.count() == 8 # There should be 2 happy hours in total assert HappyHour.objects.count() == 2 # From first happy hour there should be 4 ranges # Mon 21-23, Tue 0-3, Tue 21-23, Wed 0-3 # From second happy hour there should be 2 ranges # Wed 14-16 and Sun 14-16 assert TimeRange.objects.count() == 6 # Let's go through all our 8 discounts to make sure all is good first_discount = Discount.objects.filter( product=product1, category__isnull=True, contact__isnull=True, contact_group__isnull=True).first() assert first_discount.happy_hours.count() == 1 assert first_discount.discount_amount_value == discount_amount_value second_discount = Discount.objects.filter( product=product2, category__isnull=True, contact__isnull=True, contact_group__isnull=True).first() assert second_discount.happy_hours.count() == 0 assert second_discount.discount_amount_value == discount_amount_value third_discount = Discount.objects.filter( product=product3, category__isnull=True, contact__isnull=True, contact_group__isnull=True).first() assert third_discount.happy_hours.count() == 0 assert third_discount.discount_amount_value == discount_amount_value category_discount = Discount.objects.filter( product__isnull=True, category=category, contact__isnull=True, contact_group__isnull=True).first() assert category_discount.happy_hours.count() == 0 assert category_discount.discount_percentage == discount_percentage contact_discount = Discount.objects.filter( product=product1, category__isnull=True, contact=contact1, contact_group__isnull=True).first() assert contact_discount.discount_amount_value == discount_amount_value product1_contact_group_discount = Discount.objects.filter( product=product1, category__isnull=True, contact__isnull=True, contact_group=contact_group).first() assert product1_contact_group_discount.happy_hours.count() == 1 assert product1_contact_group_discount.discount_percentage == discount_percentage product2_contact_group_discount = Discount.objects.filter( product=product2, category__isnull=True, contact__isnull=True, contact_group=contact_group).first() assert product2_contact_group_discount.happy_hours.count() == 1 assert product2_contact_group_discount.discount_percentage == discount_percentage product3_contact_group_discount = Discount.objects.filter( product=product3, category__isnull=True, contact__isnull=True, contact_group=contact_group).first() assert product3_contact_group_discount.happy_hours.count() == 1 assert product3_contact_group_discount.discount_percentage == discount_percentage
def test_reorder_view(): shop = factories.get_default_shop() factories.get_default_shipping_method() factories.get_default_payment_method() supplier1 = factories.get_supplier(SimpleSupplierModule.identifier, shop=shop) supplier2 = factories.get_supplier(SimpleSupplierModule.identifier, shop=shop) assert supplier1.pk != supplier2.pk product_supplier1 = factories.create_product( "product_supplier1", shop=shop, supplier=supplier1, default_price=10, shipping_mode=ShippingMode.NOT_SHIPPED ) product_supplier2 = factories.create_product( "product_supplier2", shop=shop, supplier=supplier2, default_price=20, shipping_mode=ShippingMode.NOT_SHIPPED ) user = factories.create_random_user("en") user.set_password("user") user.save() customer = factories.create_random_person("en") customer.user = user customer.save() order = factories.create_random_order( customer=customer, shop=shop, products=[product_supplier1, product_supplier2], completion_probability=0, random_products=False ) suppliers = [line.supplier for line in order.lines.products()] assert supplier1 in suppliers assert supplier2 in suppliers client = Client() client.login(username=user.username, password="******") # list orders response = client.get(reverse("E-Commerce:personal-orders")) assert response.status_code == 200 content = response.content.decode("utf-8") assert "<td>%d</td>" % order.id in content assert "<td>Received</td>" in content # go to order detail response = client.get(reverse("E-Commerce:show-order", kwargs=dict(pk=order.pk))) assert response.status_code == 200 content = response.content.decode("utf-8") assert "Add all products to cart" in content reorder_url = reverse("E-Commerce:reorder-order", kwargs=dict(pk=order.pk)) assert reorder_url in content # reorder products response = client.get(reorder_url) assert response.status_code == 302 assert response.url.endswith(reverse("E-Commerce:basket")) # go to basket response = client.get(response.url) assert response.status_code == 200 content = response.content.decode("utf-8") # ensure the basket contain those products and suppliers basket_key = client.session["basket_basket_key"]["key"] from E-Commerce.front.models import StoredBasket basket = StoredBasket.objects.get(key=basket_key) lines = basket.data["lines"] product_supplier = [(line["product_id"], line["supplier_id"]) for line in lines] assert (product_supplier1.pk, supplier1.pk) in product_supplier assert (product_supplier2.pk, supplier2.pk) in product_supplier assert product_supplier1.name in content assert product_supplier2.name in content assert "You are unable to proceed to checkout!" not in content
def test_index_view_with_contact_limitatons(): shop = factories.get_default_shop() password = "******" # Person 1 to test contact and person contact layouts person1 = factories.create_random_person(shop=shop) person1.user = factories.create_random_user() person1.user.set_password(password) person1.user.save() person1.save() # Person 2 to test company layout person2 = factories.create_random_person(shop=shop) person2.user = factories.create_random_user() person2.user.set_password(password) person2.user.save() person2.save() company = factories.create_random_company(shop=shop) company.members.add(person2) placeholder_name = "front_content" request = get_request() context = {"request": request} # Add plugin for anons vc = _get_basic_view_config(view_name="IndexView") anon_plugin_text = "This content is only for guests" layout = vc.get_placeholder_layout(AnonymousContactLayout, placeholder_name, context=context) _add_plugin_and_test_save(vc, layout, placeholder_name, context, anon_plugin_text) # Add plugin for contact vc = _get_basic_view_config(view_name="IndexView") context["request"].customer = person1 contact_plugin_text = "This content is only for users logged in" layout = vc.get_placeholder_layout(ContactLayout, placeholder_name, context=context) _add_plugin_and_test_save(vc, layout, placeholder_name, context, contact_plugin_text) # Add plugin for person contacts vc = _get_basic_view_config(view_name="IndexView") person_contact_plugin_text = "This content is only for person contacts" layout = vc.get_placeholder_layout(PersonContactLayout, placeholder_name, context=context) _add_plugin_and_test_save(vc, layout, placeholder_name, context, person_contact_plugin_text) # Add plugin for companies vc = _get_basic_view_config(view_name="IndexView") context["request"].customer = company company_plugin_text = "This content is only for companies" layout = vc.get_placeholder_layout(CompanyContactLayout, placeholder_name, context=context) _add_plugin_and_test_save(vc, layout, placeholder_name, context, company_plugin_text) c = SmartClient() # By default there is no user logged in soup = c.soup(reverse("E-Commerce:index")) page_content = soup.find("div", {"class": "page-content"}) page_content_text = page_content.text assert anon_plugin_text in page_content_text assert contact_plugin_text not in page_content_text assert person_contact_plugin_text not in page_content_text assert company_plugin_text not in page_content_text # Login as person1 user c = SmartClient() c.login(username=person1.user.username, password=password) soup = c.soup(reverse("E-Commerce:index")) page_content = soup.find("div", {"class": "page-content"}) page_content_text = page_content.text assert anon_plugin_text not in page_content_text assert contact_plugin_text in page_content_text assert person_contact_plugin_text in page_content_text assert company_plugin_text not in page_content_text # Login as person2 user which is linked to company c = SmartClient() c.login(username=person2.user.username, password=password) soup = c.soup(reverse("E-Commerce:index")) page_content = soup.find("div", {"class": "page-content"}) page_content_text = page_content.text assert anon_plugin_text not in page_content_text assert contact_plugin_text in page_content_text assert person_contact_plugin_text not in page_content_text assert company_plugin_text in page_content_text
def test_create_order(admin_user, target_customer): with override_settings(**REQUIRED_SETTINGS): set_configuration() factories.create_default_order_statuses() shop = factories.get_default_shop() client = _get_client(admin_user) # Create basket for target customer payload = {"shop": shop.pk} target = orderer = get_person_contact(admin_user) if target_customer == "other_person": target = orderer = factories.create_random_person() payload["customer"] = target.pk elif target_customer == "company": target = factories.create_random_company() orderer = factories.create_random_person() payload.update({ "customer": target.pk, "orderer": orderer.pk }) target.members.add(orderer) response = client.post("/api/E-Commerce/basket/new/", payload) 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.customer == target assert basket.orderer == orderer shop_product = factories.get_default_shop_product() shop_product.default_price = TaxfulPrice(1, shop.currency) shop_product.save() # Add shop product to basket payload = {"shop_product": shop_product.id} response = client.post("/api/E-Commerce/basket/{}-{}/add/".format(shop.pk, basket.key), payload) assert response.status_code == status.HTTP_200_OK response_data = json.loads(response.content.decode("utf-8")) assert len(response_data["items"]) == 1 # Create order from basket response = client.post("/api/E-Commerce/basket/{}-{}/create_order/".format(shop.pk, basket.key), payload) assert response.status_code == status.HTTP_400_BAD_REQUEST response_data = json.loads(response.content.decode("utf-8")) assert "errors" in response_data factories.get_default_payment_method() factories.get_default_shipping_method() response = client.post("/api/E-Commerce/basket/{}-{}/create_order/".format(shop.pk, basket.key), payload) assert response.status_code == status.HTTP_201_CREATED response_data = json.loads(response.content.decode("utf-8")) basket.refresh_from_db() assert basket.finished order = Order.objects.get(reference_number=response_data["reference_number"]) assert order.status == OrderStatus.objects.get_default_initial() assert order.payment_status == PaymentStatus.NOT_PAID assert order.shipping_status == ShippingStatus.NOT_SHIPPED assert not order.payment_method assert not order.shipping_method assert float(order.taxful_total_price_value) == 1 assert order.customer == target assert order.orderer == orderer assert order.creator == admin_user assert not order.billing_address assert not order.shipping_address
def test_basket_reorder_staff_user(): with override_settings(**REQUIRED_SETTINGS): set_configuration() shop = factories.get_default_shop() factories.get_default_payment_method() factories.get_default_shipping_method() staff_user = User.objects.create(username="******", is_staff=True) client = _get_client(staff_user) person = factories.create_random_person() # create an order for the person product = create_product("product", shop=shop, supplier=get_default_supplier(), default_price='12.4') order = create_random_order(customer=person, products=[product], completion_probability=1, shop=shop) # create the basket response = client.post("/api/E-Commerce/basket/new/", data={"shop": shop.pk, "customer": person.pk}, format="json") # 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}, format="json") 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 # 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}, format="json") 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 assert basket.creator == staff_user assert basket.customer.pk == person.pk # add contents to the basket from a customer order response = client.post('/api/E-Commerce/basket/{}-{}/add_from_order/'.format(shop.pk, basket.key), data={"order": order.pk}, format="json") assert response.status_code == status.HTTP_200_OK basket_data = json.loads(response.content.decode("utf-8")) assert len(basket_data['items']) > 0 assert Decimal(basket_data['taxful_total_price']) == order.taxful_total_price_value # finally create the order response = client.post('/api/E-Commerce/basket/{}-{}/create_order/'.format(shop.pk, basket.key)) assert response.status_code == status.HTTP_201_CREATED response_data = json.loads(response.content.decode("utf-8")) created_order = Order.objects.get(id=response_data['id']) assert created_order.creator == staff_user assert created_order.customer == person # create a second customer person2 = factories.create_random_person() # create a basket for customer 2 and try to fill with contents of customer 1 order - it should not be possible response = client.post("/api/E-Commerce/basket/new/", data={"shop": shop.pk, "customer": person2.pk}, format="json") 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 == person2.pk # add contents to the basket from customer 1 order - error response = client.post('/api/E-Commerce/basket/{}-{}/add_from_order/'.format(shop.pk, basket.key), data={"order": order.pk}, format="json") assert response.status_code == status.HTTP_404_NOT_FOUND assert 'invalid order' in response.content.decode("utf-8")