def test_order_creator_account_manager():
company = create_random_company()
shop = get_shop(identifier="random-shop", enabled=True)
source = seed_source(create_random_user(), shop)
source.customer = company
source.add_line(
type=OrderLineType.PRODUCT,
product=get_default_product(),
supplier=get_default_supplier(),
quantity=1,
base_unit_price=source.create_price(10),
)
creator = OrderCreator()
order = creator.create_order(source)
assert order.account_manager is None # Company contact doesn't have account manager field
person = create_random_person()
person.account_manager = create_random_person()
person.save()
source = seed_source(create_random_user(), shop)
source.customer = person
source.add_line(
type=OrderLineType.PRODUCT,
product=get_default_product(),
supplier=get_default_supplier(),
quantity=1,
base_unit_price=source.create_price(10),
)
creator = OrderCreator()
order = creator.create_order(source)
assert order.account_manager is not None
assert order.account_manager == person.account_manager
with pytest.raises(ProtectedError):
person.account_manager.delete()
def test_category_links_plugin_with_customer(rf, show_all_categories):
"""
Test plugin for categories that is visible for certain group
"""
shop = get_default_shop()
group = get_default_customer_group()
customer = create_random_person()
customer.groups.add(group)
customer.save()
request = rf.get("/")
request.shop = get_default_shop()
apply_request_middleware(request)
request.customer = customer
category = get_default_category()
category.status = CategoryStatus.VISIBLE
category.visibility = CategoryVisibility.VISIBLE_TO_GROUPS
category.visibility_groups.add(group)
category.shops.add(shop)
category.save()
vars = {"request": request}
context = get_jinja_context(**vars)
plugin = CategoryLinksPlugin({"categories": [category.pk], "show_all_categories": show_all_categories})
assert category.is_visible(customer)
assert category in plugin.get_context_data(context)["categories"]
customer_without_groups = create_random_person()
customer_without_groups.groups.clear()
assert not category.is_visible(customer_without_groups)
request.customer = customer_without_groups
context = get_jinja_context(**vars)
assert category not in plugin.get_context_data(context)["categories"]
def test_basket_contact_condition(rf):
product_price_value, campaign_discount_value = 2, 1
request = get_request_for_contact_tests(rf)
random_person = create_random_person()
request.customer = random_person
condition = ContactBasketCondition.objects.create()
condition.contacts.add(random_person)
basket, original_line_count, original_price = create_basket_and_campaign(
request, [condition], product_price_value, campaign_discount_value)
# random_person should get this campaign
assert basket.customer == random_person
assert_discounted_basket(basket, original_line_count, original_price,
campaign_discount_value)
another_random_person = create_random_person()
basket.customer = another_random_person
# another random person shouldn't
assert_non_discounted_basket(basket, original_line_count, original_price)
# Add another random person for the rule and see if he get's the discount
condition.contacts.add(another_random_person)
condition.save()
assert_discounted_basket(basket, original_line_count, original_price,
campaign_discount_value)
assert basket.customer == another_random_person
# Remove random person from rule and see the discount disappear
condition.contacts.remove(random_person)
condition.save()
basket.customer = random_person
assert_non_discounted_basket(basket, original_line_count, original_price)
assert basket.customer == random_person
def test_total_sales_customers_report(rf):
shop = get_default_shop()
supplier = get_default_supplier()
p1 = create_product("p1", shop=shop, supplier=supplier, default_price="5")
p2 = create_product("p2", shop=shop, supplier=supplier, default_price="20")
# orders for person 1
person1 = create_random_person()
order1 = create_random_order(customer=person1,
completion_probability=1,
products=[p1, p2])
order2 = create_random_order(customer=person1,
completion_probability=1,
products=[p1, p2])
# orders for person 2
person2 = create_random_person()
order3 = create_random_order(customer=person2,
completion_probability=1,
products=[p1, p2])
order4 = create_random_order(customer=person2,
completion_probability=1,
products=[p1, p2])
order5 = create_random_order(customer=person2,
completion_probability=1,
products=[p1, p2])
# pay orders
[o.create_payment(o.taxful_total_price) for o in Order.objects.all()]
data = {
"report": TotalSales.get_name(),
"shop": shop.pk,
"date_range": DateRangeChoices.ALL_TIME,
"writer": "json",
"force_download": 1,
}
report = TotalSales(**data)
writer = get_writer_instance(data["writer"])
response = writer.get_response(report=report)
if hasattr(response, "render"):
response.render()
json_data = json.loads(response.content.decode("utf-8"))
assert force_text(TotalSales.title) in json_data.get("heading")
data = json_data.get("tables")[0].get("data")[0]
avg_sales = (order1.taxful_total_price + order2.taxful_total_price +
order3.taxful_total_price + order4.taxful_total_price +
order5.taxful_total_price) / Decimal(5)
assert int(data["customers"]) == 2
assert int(data["order_amount"]) == 5
assert data["customer_avg_sale"] == str(
avg_sales.value.quantize(Decimal('0.01')))
def test_get_by_pk(admin_user):
get_default_shop()
for i in range(0, 10):
create_random_person()
contact = create_random_person()
client = _get_client(admin_user)
response = client.get("/api/wshop/contact/%s/" % contact.id)
assert response.status_code == status.HTTP_200_OK
contact_data = json.loads(response.content.decode("utf-8"))
assert contact_data.get("id") == contact.id
assert contact_data.get("name") == contact.name
def test_get_shipments(admin_user):
client = _get_client(admin_user)
shop1 = get_shop(True)
shop2 = get_shop(True)
customer1 = create_random_person()
customer2 = create_random_person()
order1 = create_random_order(customer1, shop=shop1, completion_probability=1)
order2 = create_random_order(customer2, shop=shop1, completion_probability=1)
order3 = create_random_order(customer1, shop=shop2, completion_probability=1)
order4 = create_random_order(customer2, shop=shop1, completion_probability=1)
# list shipments
response = client.get("/api/wshop/shipment/")
assert response.status_code == status.HTTP_200_OK
shipment_data = json.loads(response.content.decode("utf-8"))
assert len(shipment_data) == 4
assert shipment_data[0]["id"] == order1.shipments.first().pk
assert shipment_data[1]["id"] == order2.shipments.first().pk
assert shipment_data[2]["id"] == order3.shipments.first().pk
assert shipment_data[3]["id"] == order4.shipments.first().pk
# get shipment by id
response = client.get("/api/wshop/shipment/%s/" % order1.shipments.first().pk)
assert response.status_code == status.HTTP_200_OK
shipment_data = json.loads(response.content.decode("utf-8"))
assert shipment_data["id"] == order1.shipments.first().pk
assert shipment_data["order"] == order1.pk
# get shipment by product
product = order2.shipments.first().products.first()
response = client.get("/api/wshop/shipment/?product=%s" % product.pk)
assert response.status_code == status.HTTP_200_OK
shipment_data = json.loads(response.content.decode("utf-8"))
for ship in shipment_data:
for ship_product in shipment_data["product"]:
assert ship_product["id"] == product.pk
assert ship_product["order"] == order2.pk
# get shipment by order
response = client.get("/api/wshop/shipment/?order=%s" % order3.pk)
assert response.status_code == status.HTTP_200_OK
shipment_data = json.loads(response.content.decode("utf-8"))
for ship in shipment_data:
assert ship["order"] == order3.pk
# get shipment by shop
response = client.get("/api/wshop/shipment/?shop=%s" % shop1.pk)
assert response.status_code == status.HTTP_200_OK
shipment_data = json.loads(response.content.decode("utf-8"))
for ship in shipment_data:
assert Shipment.objects.filter(pk=ship["id"], order__shop=shop1).exists()
def test_contact_details_view_with_many_groups(rf, admin_user):
get_default_shop()
person = create_random_person()
person.groups.add(
ContactGroup.objects.create(name="Czz Group"),
ContactGroup.objects.create(name="Azz Group"),
ContactGroup.objects.create(name="Bzz Group"),
ContactGroup.objects.language('fi').create(name="Dzz ryhmä"),
)
# Group with name in two languages
grp_e = ContactGroup.objects.language('en').create(name="Ezz Group")
grp_e.set_current_language('fi')
grp_e.name = "Ezz ryhmä"
grp_e.save()
person.groups.add(grp_e)
request = apply_request_middleware(rf.get("/"), user=admin_user)
with translation.override('en'):
view_func = ContactDetailView.as_view()
response = view_func(request, pk=person.pk)
content = response.render().content.decode('utf-8')
assert "Azz Group" in content
assert "Bzz Group" in content
assert "Czz Group" in content
assert "Dzz ryhmä" in content, "no name in active language, still present"
assert "Ezz Group" in content, "rendered with active language"
positions = [content.index(x + "zz ") for x in 'ABCDE']
assert positions == sorted(positions), "Groups are sorted"
assert response.status_code == 200
def test_filter_parameter_contact_groups():
customer_price = 10.3
anonymous_price = 14.6
def get_price_info_mock(context, product, quantity=1):
if context.customer.get_default_group() == AnonymousContact(
).get_default_group():
price = context.shop.create_price(anonymous_price)
else:
price = context.shop.create_price(customer_price)
return PriceInfo(quantity * price, quantity * price, quantity)
with patch.object(DummyPricingModule,
'get_price_info',
side_effect=get_price_info_mock):
(engine, context) = _get_template_engine_and_context(product_sku="123")
# test with anonymous
context['request'].customer = AnonymousContact()
context['request'].person = context['request'].customer
result = engine.from_string("{{ prod|price(quantity=2) }}")
assert result.render(context) == "$%0.2f" % (anonymous_price * 2)
# Get fresh content. I guess the prices shouldn't change between request.
(engine,
context) = _get_template_engine_and_context(product_sku="1234")
# test with customer
context['request'].customer = create_random_person()
context['request'].person = context['request'].customer
result = engine.from_string("{{ prod|price(quantity=2) }}")
assert result.render(context) == "$%0.2f" % (customer_price * 2)
def test_parallel_baskets(rf):
request = get_request_with_basket()
shop = get_default_shop()
customer = create_random_person()
request = rf.get("/")
request.shop = shop
apply_request_middleware(request)
request.customer = customer
basket_one = get_basket(request, basket_name="basket_one")
basket_two = get_basket(request, basket_name="basket_two")
product_one = get_default_product()
product_two = get_default_product()
product_two.sku = "derpy-hooves"
sales_unit = SalesUnit.objects.create(identifier="test-sales-partial",
decimals=2,
name="Partial unit")
product_two.sales_unit = sales_unit # Set the sales unit for the product
product_two.save()
basket_commands.handle_add(request,
basket_one,
product_id=product_one.pk,
quantity=1)
basket_commands.handle_add(request,
basket_two,
product_id=product_two.pk,
quantity=3.5)
assert basket_one.product_count == 1
assert basket_two.product_count == 3.5
def test_contact_module_search_multishop(rf):
with override_settings(WSHOP_MANAGE_CONTACTS_PER_SHOP=True,
WSHOP_ENABLE_MULTIPLE_SHOPS=True):
staff_user = create_random_user(is_staff=True)
shop1 = get_shop(identifier="shop-1", enabled=True)
shop2 = get_shop(identifier="shop-2", enabled=True)
shop1.staff_members.add(staff_user)
shop2.staff_members.add(staff_user)
cm = ContactModule()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
contact.shops.add(shop2)
request = apply_request_middleware(rf.get("/"),
user=staff_user,
shop=shop2)
# find the shop
assert not empty_iterable(
cm.get_search_results(request, query=contact.email))
assert not empty_iterable(
cm.get_search_results(request, query=contact.first_name))
# no shop found
request = apply_request_middleware(rf.get("/"),
user=staff_user,
shop=shop1)
assert empty_iterable(
cm.get_search_results(request, query=contact.email))
def test_sales_ranges_update_after_range_update():
shop = get_default_shop()
supplier = get_default_supplier()
person = create_random_person()
company = create_random_company()
create_fully_paid_order(shop, person, supplier, "sku1", 50)
create_fully_paid_order(shop, company, supplier, "sku2", 100)
assert get_total_sales(shop, person) == 50
assert get_total_sales(shop, company) == 100
sales_range = create_sales_range("gold", shop, 10, 90)
assert sales_range.group in person.groups.all()
assert sales_range.group not in company.groups.all()
sales_range.max_value = None
sales_range.save()
assert sales_range.group in person.groups.all()
assert sales_range.group in company.groups.all()
# Make sure customers is actually removed when range changes
sales_range.max_value = 60
sales_range.save()
assert sales_range.group in person.groups.all()
assert sales_range.group not in company.groups.all()
# Inactive ranges shouldn't update group members
sales_range.min_value = None
sales_range.save()
assert sales_range.group in person.groups.all()
assert sales_range.group not in company.groups.all()
def test_sales_between_ranges():
shop = get_default_shop()
supplier = get_default_supplier()
person = create_random_person()
initial_group_count = person.groups.count()
sales_ranges = [("wood", 15, 0), ("silver", 0, 50), ("diamond", 100, None)]
for identifier, min, max in sales_ranges:
create_sales_range(identifier, shop, min, max)
payment = create_fully_paid_order(shop, person, supplier, "sku1", 10)
assert get_total_sales(shop, person) == 10
update_customers_groups(Payment, payment)
assert person.groups.count() == (initial_group_count + 1)
assert bool([
group for group in person.groups.all() if group.identifier == "silver"
])
assert not bool(
[group for group in person.groups.all() if group.identifier == "wood"])
payment = create_fully_paid_order(shop, person, supplier, "sku2", 50)
assert get_total_sales(shop, person) == 60
update_customers_groups(Payment, payment)
assert person.groups.count() == initial_group_count
assert not bool([
group for group in person.groups.all()
if group.identifier in ["silver", "gold", "diamond"]
])
payment = create_fully_paid_order(shop, person, supplier, "sku3", 200)
assert get_total_sales(shop, person) == 260
update_customers_groups(Payment, payment)
assert person.groups.count() == (initial_group_count + 1)
assert bool([
group for group in person.groups.all() if group.identifier == "diamond"
])
def test_mass_edit_orders(rf, admin_user):
shop = get_default_shop()
supplier = get_default_supplier()
contact1 = create_random_person()
product1 = create_product(printable_gibberish(),
shop=shop,
supplier=supplier,
default_price="50")
product2 = create_product(printable_gibberish(),
shop=shop,
supplier=supplier,
default_price="501")
order = create_random_order(customer=contact1,
products=[product1, product2],
completion_probability=0)
assert order.status.role != OrderStatusRole.CANCELED
payload = {"action": CancelOrderAction().identifier, "values": [order.pk]}
request = apply_request_middleware(rf.post(
"/",
user=admin_user,
))
request._body = json.dumps(payload).encode("UTF-8")
view = OrderListView.as_view()
response = view(request=request)
assert response.status_code == 200
for order in Order.objects.all():
assert order.status.role == OrderStatusRole.CANCELED
def test_product_pricing_cache(admin_user):
shop = get_default_shop()
group = create_random_contact_group()
group2 = create_random_contact_group()
product = create_product("Just-A-Product", shop, default_price=200)
CgpPrice.objects.create(product=product, shop=shop, group=group, price_value=175)
CgpPrice.objects.create(product=product, shop=shop, group=group2, price_value=150)
client = _get_client(admin_user)
response = client.get("/api/wshop/front/shop_products/")
products_data = json.loads(response.content.decode("utf-8"))
assert products_data[0]["price"] == 200
user = get_user_model().objects.first()
user.pk = None
user.username = "******"
user.save()
customer = create_random_person()
customer.groups.add(group)
customer.user = user
customer.save()
client = _get_client(user)
response = client.get("/api/wshop/front/shop_products/")
products_data = json.loads(response.content.decode("utf-8"))
assert products_data[0]["price"] == 175
client = _get_client(admin_user)
response = client.get("/api/wshop/front/shop_products/")
products_data = json.loads(response.content.decode("utf-8"))
assert products_data[0]["price"] == 200
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.shops.add(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_coupon_amount_limit():
coupon = Coupon.objects.create(code="TEST", active=True)
get_default_campaign(coupon)
contact = create_random_person()
shop = get_default_shop()
product = create_product("test",
shop=shop,
supplier=get_default_supplier(),
default_price="12")
order = create_random_order(customer=contact)
for x in range(50):
coupon.use(order)
assert coupon.usages.count() == 50
coupon.increase_usage_limit_by(5)
coupon.save()
assert coupon.usage_limit == 55
assert coupon.can_use_code(contact)
for x in range(5):
coupon.use(order)
assert coupon.usages.count() == 55
assert not Coupon.is_usable(coupon.code, order.customer)
assert coupon.usages.count() == 55 # no change, limit met
def test_campaign_with_non_active_coupon(rf):
initial_status = get_initial_order_status()
request, shop, group = initialize_test(rf, include_tax=False)
order = _get_order_with_coupon(request, initial_status)
coupon = order.coupon_usages.first().coupon
coupon.active = False
coupon.save()
modifier = UserFactory()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
assert order.customer != contact
state = _get_frontend_order_state(shop, contact)
assert order.shop.id == state["shop"]["selected"]["id"]
request = get_frontend_request_for_command(state, "finalize", modifier)
response = OrderEditView.as_view()(request, pk=order.pk)
assert_contains(response, "orderIdentifier")
data = json.loads(response.content.decode("utf8"))
edited_order = Order.objects.get(pk=order.pk)
assert edited_order.identifier == data[
"orderIdentifier"] == order.identifier
assert edited_order.pk == order.pk
assert edited_order.lines.count() == 3
assert OrderLineType.DISCOUNT not in [
l.type for l in edited_order.lines.all()
]
assert edited_order.coupon_usages.count() == 0
def get_order_for_date(dt, product):
order = create_random_order(customer=create_random_person(),
products=[product])
order.order_date = to_aware(dt)
order.status = OrderStatus.objects.get_default_complete()
order.save()
return order
def test_order_chart_works(rf, admin_user):
get_default_shop()
order = create_random_order(customer=create_random_person(),
products=(get_default_product(), ))
request = apply_request_middleware(rf.get("/"), user=admin_user)
chart = OrderValueChartDashboardBlock("test", request=request).get_chart()
assert len(chart.datasets[0]) > 0
def test_mass_edit_orders2(rf, admin_user):
shop = get_default_shop()
supplier = get_default_supplier()
contact1 = create_random_person()
product1 = create_product(printable_gibberish(),
shop=shop,
supplier=supplier,
default_price="50")
product2 = create_product(printable_gibberish(),
shop=shop,
supplier=supplier,
default_price="501")
order = create_random_order(customer=contact1,
products=[product1, product2],
completion_probability=0)
assert order.status.role != OrderStatusRole.CANCELED
payload = {
"action": OrderConfirmationPdfAction().identifier,
"values": [order.pk]
}
request = apply_request_middleware(rf.post(
"/",
user=admin_user,
))
request._body = json.dumps(payload).encode("UTF-8")
view = OrderListView.as_view()
response = view(request=request)
assert response.status_code == 200
if weasyprint:
assert response[
'Content-Disposition'] == 'attachment; filename=order_%s_confirmation.pdf' % order.pk
else:
assert response["content-type"] == "application/json"
def test_contact_company_list_multishop(rf):
with override_settings(WSHOP_MANAGE_CONTACTS_PER_SHOP=True, WSHOP_ENABLE_MULTIPLE_SHOPS=True):
staff_user = create_random_user(is_staff=True)
shop1 = get_shop(identifier="shop-1", enabled=True)
shop2 = get_shop(identifier="shop-2", enabled=True)
shop1.staff_members.add(staff_user)
shop2.staff_members.add(staff_user)
# only available in shop2
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
contact.shops.add(shop2)
# only available in shop1
company = create_random_company()
company.shops.add(shop1)
view = ContactListView()
request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop1)
view.request = request
assert company in view.get_queryset()
assert contact not in view.get_queryset()
request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop2)
view.request = request
assert contact in view.get_queryset()
assert company not in view.get_queryset()
def test_get_by_email(admin_user):
get_default_shop()
for i in range(0, 10):
create_random_person()
contact = create_random_person()
client = _get_client(admin_user)
response = client.get("/api/wshop/contact/", data={"email": contact.email})
assert response.status_code == status.HTTP_200_OK
contact_data = json.loads(response.content.decode("utf-8"))
assert Contact.objects.filter(
email=contact.email).count() == len(contact_data)
assert contact_data[0].get("id") == contact.id
assert contact_data[0].get("email") == contact.email
assert contact_data[0].get("name") == contact.name
def test_order_creator_source_data(rf, admin_user):
get_initial_order_status() # Needed for the API
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
request = get_frontend_request_for_command(
get_frontend_order_state(contact), "source_data", admin_user)
response = OrderEditView.as_view()(request)
data = json.loads(response.content.decode("utf8"))
assert len(data.get("orderLines")) == 5
def test_mass_edit_contacts2(rf, admin_user):
activate("en")
shop = get_default_shop()
contact1 = create_random_person()
contact2 = create_random_person()
contact_group = ContactGroup.objects.create(name="test")
data = {"contact_group": contact_group.pk}
request = apply_request_middleware(rf.post("/", data=data),
user=admin_user)
request.session["mass_action_ids"] = [contact1.pk, contact2.pk]
view = ContactGroupMassEditView.as_view()
response = view(request=request)
assert response.status_code == 302
contact_group = ContactGroup.objects.first()
for contact in Contact.objects.all():
assert contact in contact_group.members.all()
def test_order_creator_view_for_customer(rf, admin_user):
get_default_shop()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
request = apply_request_middleware(rf.get("/", {"contact_id": contact.id}),
user=admin_user)
response = OrderEditView.as_view()(request)
assert_contains(response, "customerData") # in the config
assert_contains(response, "isCompany") # in the config
def test_contact_detail_has_custom_toolbar_button(rf, admin_user):
get_default_shop()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
request = apply_request_middleware(rf.get("/"), user=admin_user)
view_func = ContactDetailView.as_view()
response = view_func(request, pk=contact.pk)
content = force_text(response.render().content)
assert "#mocktoolbarbutton" in content, 'custom toolbar button not found on detail page'
def test_get_by_contact_group(admin_user):
get_default_shop()
for i in range(0, 10):
create_random_person()
contact = create_random_person()
group = get_default_customer_group()
group.members.add(contact)
client = _get_client(admin_user)
response = client.get("/api/wshop/contact/", data={"groups": group.id})
assert response.status_code == status.HTTP_200_OK
contact_data = json.loads(response.content.decode("utf-8"))
assert group.members.count() == len(contact_data)
assert contact_data[0].get("id") == contact.id
assert contact_data[0].get("email") == contact.email
assert contact_data[0].get("name") == contact.name
def test_without_groups(admin_user):
payment_method = get_default_payment_method()
_assign_component_for_service(payment_method, [])
person = create_random_person()
person.user = admin_user
person.save()
source = _get_source_for_contact(admin_user, payment_method)
assert source.customer == person
_test_service_availability(source, payment_method, False)
def test_mass_edit_contacts(rf, admin_user):
shop = get_default_shop()
contact1 = create_random_person()
contact2 = create_random_person()
contact1.gender = Gender.FEMALE
contact1.save()
contact2.gender = Gender.FEMALE
contact2.save()
contact_ids = [contact1.pk, contact2.pk]
request = apply_request_middleware(rf.post(
"/", data={"gender": Gender.MALE.value}),
user=admin_user)
request.session["mass_action_ids"] = contact_ids
view = ContactMassEditView.as_view()
response = view(request=request)
assert response.status_code == 302
for contact in Contact.objects.filter(id__in=contact_ids):
assert contact.gender == Gender.MALE
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
