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_context_contact_condition():
rf = RequestFactory()
original_price_value, discount_value = 2, 1
request = get_request_for_contact_tests(rf)
random_person = create_random_person()
condition = ContactCondition.objects.create()
condition.contacts.add(random_person)
product = create_random_product_and_campaign(request.shop, [condition], original_price_value, discount_value)
# random_person should get this campaign
discounted_value = original_price_value - discount_value
assert_product_price_value_with_customer(request, random_person, product, discounted_value)
another_random_person = create_random_person()
# another random person shouldn't
assert_product_price_value_with_customer(request, another_random_person, product, original_price_value)
# Add another random person for the rule and see if he get's the discount
condition.contacts.add(another_random_person)
assert_product_price_value_with_customer(request, another_random_person, product, discounted_value)
# Remove random person from rule and see the discount disappear
condition.contacts.remove(random_person)
condition.save()
assert_product_price_value_with_customer(request, random_person, product, original_price_value)
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_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_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/shuup/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/shuup/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/shuup/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/shuup/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/shuup/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/shuup/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_min_amount_is_not_included():
shop = get_default_shop()
supplier = get_default_supplier()
person = create_random_person()
initial_group_count = person.groups.count()
sales_ranges = [
("silver", 0, 50),
("gold", 50, 100),
("diamond", 100, 1000),
("reverse_diamond", 1000, 100)
]
for identifier, min, max in sales_ranges:
create_sales_range(identifier, shop, min, max)
payment = create_fully_paid_order(shop, person, supplier, "sku1", 50)
assert get_total_sales(shop, person) == 50
update_customers_groups(Payment, payment)
assert person.groups.count() == (initial_group_count + 1)
assert bool([group for group in person.groups.all() if group.identifier == "gold"])
assert not bool([group for group in person.groups.all() if group.identifier in ["silver", "diamond"]])
payment = create_fully_paid_order(shop, person, supplier, "sku2", 50)
assert get_total_sales(shop, person) == 100
update_customers_groups(Payment, payment)
assert person.groups.count() == (initial_group_count + 1)
assert bool([group for group in person.groups.all() if group.identifier == "diamond"])
assert not bool([group for group in person.groups.all() if group.identifier == "reverse_diamond"])
assert not bool([group for group in person.groups.all() if group.identifier in ["silver", "gold"]])
def 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_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/shuup/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/shuup/basket/new/", data={"shop": 1000})
assert response.status_code == status.HTTP_400_BAD_REQUEST
# no shop in multishop mode
response = client.post("/api/shuup/basket/new/")
assert response.status_code == status.HTTP_400_BAD_REQUEST
# no shop in single shop mode
with override_settings(SHUUP_ENABLE_MULTIPLE_SHOPS=False):
response = client.post("/api/shuup/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/shuup/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/shuup/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_product_price_info(admin_user, prices_include_tax):
shop = get_default_shop()
shop.prices_include_tax = prices_include_tax
shop.save()
customer = create_random_person()
group = customer.get_default_group()
customer.user = admin_user
customer.groups.add(group)
customer.save()
PRICE = 200.0
DISCOUNT = 15.0
product = create_product("Just-A-Product", shop, default_price=PRICE)
CgpDiscount.objects.create(product=product, shop=shop, group=group, discount_amount_value=DISCOUNT)
client = _get_client(admin_user)
response = client.get("/api/shuup/front/shop_products/")
products_data = json.loads(response.content.decode("utf-8"))
assert products_data[0]["price"] == (PRICE-DISCOUNT)
assert products_data[0]["price_info"]['base_price'] == PRICE
assert products_data[0]["price_info"]['price'] == (PRICE-DISCOUNT)
assert products_data[0]["price_info"]['discount_amount'] == DISCOUNT
assert products_data[0]["price_info"]['discount_rate'] == DISCOUNT/PRICE
assert products_data[0]["price_info"]['is_discounted'] is True
assert products_data[0]["price_info"]['discount_percentage'] == DISCOUNT/PRICE * 100
if prices_include_tax:
assert products_data[0]["price_info"]['taxful_price'] == (PRICE-DISCOUNT)
else:
assert products_data[0]["price_info"]['taxless_price'] == (PRICE-DISCOUNT)
def test_protected_fields():
activate("en")
shop = Shop.objects.create(
name="testshop",
identifier="testshop",
status=ShopStatus.ENABLED,
public_name="test shop",
domain="derp",
currency="EUR"
)
get_currency("EUR")
get_currency("USD")
assert shop.name == "testshop"
assert shop.currency == "EUR"
assert not ConfigurationItem.objects.filter(shop=shop, key="languages").exists()
shop_form = ShopBaseForm(instance=shop, languages=settings.LANGUAGES)
assert not shop_form._get_protected_fields() # No protected fields just yet, right?
data = get_form_data(shop_form, prepared=True)
shop_form = ShopBaseForm(data=data, instance=shop, languages=settings.LANGUAGES)
_test_cleanliness(shop_form)
shop_form.save()
# Now let's make it protected!
create_product(printable_gibberish(), shop=shop, supplier=get_default_supplier())
order = create_random_order(customer=create_random_person(), shop=shop)
assert order.shop == shop
# And try again...
data["currency"] = "USD"
shop_form = ShopBaseForm(data=data, instance=shop, languages=settings.LANGUAGES)
assert shop_form._get_protected_fields() # So protected!
_test_cleanliness(shop_form)
shop = shop_form.save()
assert shop.currency == "EUR" # But the shop form ignored the change . . .
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()
request = apply_request_middleware(rf.post("/", data={"gender": Gender.MALE.value}), user=admin_user)
request.session["mass_action_ids"] = [contact1.pk, contact2.pk]
view = ContactMassEditView.as_view()
response = view(request=request)
assert response.status_code == 302
for contact in Contact.objects.all():
assert contact.gender == Gender.MALE
def test_order_creator_customer_data(rf, admin_user):
get_default_shop()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
request = apply_request_middleware(rf.get("/", {"command": "customer_data", "id": contact.id}), user=admin_user)
response = OrderEditView.as_view()(request)
assert_contains(response, "name")
assert_contains(response, contact.name)
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_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_delete_payment(admin_user, rf):
product = get_default_product()
shop_product = product.get_shop_instance(get_default_shop())
shop_product.default_price_value = 20
shop_product.save()
order = create_random_order(customer=create_random_person(), products=(product,), completion_probability=0)
payment_amount = order.taxful_total_price_value
# create a payment
view = OrderCreatePaymentView.as_view()
request = apply_request_middleware(rf.post("/", {"amount": payment_amount}), user=admin_user)
response = view(request, pk=order.pk)
assert response.status_code == 302
order.refresh_from_db()
assert order.is_paid()
# delete the payment
payment = order.payments.last()
view = OrderDeletePaymentView.as_view()
request = apply_request_middleware(rf.post("/", {"payment": payment.pk}), user=admin_user)
response = view(request, pk=order.pk)
assert response.status_code == 302
order.refresh_from_db()
assert order.is_not_paid()
def test_order_creator_customer_details(rf, admin_user):
shop = get_default_shop()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
company = create_random_company()
group = get_default_customer_group()
contact.groups.add(group)
contact.company_memberships.add(company)
contact.save()
product = create_product(sku=printable_gibberish(), supplier=get_default_supplier(), shop=shop)
order = create_random_order(contact, products=[product])
request = apply_request_middleware(rf.get("/", {"command": "customer_details", "id": contact.id}), user=admin_user)
response = OrderEditView.as_view()(request)
data = json.loads(response.content.decode("utf8"))
assert "customer_info" in data
assert "order_summary" in data
assert "recent_orders" in data
assert data["customer_info"]["name"] == contact.full_name
assert data["customer_info"]["phone_no"] == contact.phone
assert data["customer_info"]["email"] == contact.email
assert company.full_name in data["customer_info"]["companies"]
assert group.name in data["customer_info"]["groups"]
assert data["customer_info"]["merchant_notes"] == contact.merchant_notes
assert len(data["order_summary"]) == 1
assert data["order_summary"][0]["year"] == order.order_date.year
assert data["order_summary"][0]["total"] == format_money(order.taxful_total_price)
assert len(data["recent_orders"]) == 1
assert data["recent_orders"][0]["status"] == order.get_status_display()
assert data["recent_orders"][0]["total"] == format_money(order.taxful_total_price)
assert data["recent_orders"][0]["payment_status"] == force_text(order.payment_status.label)
assert data["recent_orders"][0]["shipment_status"] == force_text(order.shipping_status.label)
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_user_detail_contact_seed(rf, admin_user):
get_default_shop()
contact = create_random_person()
# Using random data for name and email would need escaping when
# checking if it is rendered, therefore use something very basic instead
contact.name = "Matti Perustyyppi"
contact.email = "*****@*****.**"
contact.save()
view_func = UserDetailView.as_view()
# Check that fields populate . . .
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}), user=admin_user)
response = view_func(request)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
# POST the password too to create the user . . .
post = extract_form_fields(BeautifulSoup(content))
post["password"] = "******"
request.method = "POST"
request.POST = post
response = view_func(request)
assert response.status_code < 500
# Check this new user is visible in the details now
user = Contact.objects.get(pk=contact.pk).user
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}), user=admin_user)
response = view_func(request, pk=user.pk)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
def test_get_suppliable_products():
customer = create_random_person()
shop_product = get_default_shop_product()
shop = get_default_shop()
supplier = get_default_supplier()
# Check for default orderable shop product with unstocked behavior
assert len(list(supplier.get_suppliable_products(shop, customer=customer))) == 1
supplier.stock_managed = True
supplier.save()
# Make sure supplier now omits unorderable product
assert not list(supplier.get_suppliable_products(shop, customer=customer))
assert len(list(supplier.get_orderability_errors(shop_product, quantity=1, customer=customer))) == 1
shop_product.backorder_maximum = 10
shop_product.save()
assert len(list(supplier.get_suppliable_products(shop, customer=customer))) == 1
assert len(list(supplier.get_orderability_errors(shop_product, quantity=10, customer=customer))) == 0
assert len(list(supplier.get_orderability_errors(shop_product, quantity=11, customer=customer))) == 1
shop_product.backorder_maximum = None
shop_product.save()
assert len(list(supplier.get_suppliable_products(shop, customer=customer))) == 1
assert len(list(supplier.get_orderability_errors(shop_product, quantity=1000, customer=customer))) == 0
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_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_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 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/shuup/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/shuup/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/shuup/front/shop_products/")
products_data = json.loads(response.content.decode("utf-8"))
assert products_data[0]["price"] == 200
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_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_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/shuup/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_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_mass_edit_orders3(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")
order1 = create_random_order(customer=contact1,
products=[product1, product2],
completion_probability=0)
order2 = create_random_order(customer=contact1,
products=[product1, product2],
completion_probability=0)
assert order1.status.role != OrderStatusRole.CANCELED
assert order2.status.role != OrderStatusRole.CANCELED
payload = {
"action": OrderConfirmationPdfAction().identifier,
"values": [order1.pk, order2.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_confirmation_pdf.zip'
else:
assert response["content-type"] == "application/json"
def test_admin_cash_order(rf, admin_user, price, target, mode):
activate("en")
get_initial_order_status() # Needed for the API
shop = get_default_shop()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
processor = CustomPaymentProcessor.objects.create(rounding_mode=mode)
cash_method = PaymentMethod.objects.create(
shop=shop,
payment_processor=processor,
choice_identifier="cash",
tax_class=get_default_tax_class(),
name="Cash")
state = get_frontend_order_state(contact, cash_method, price)
order = get_order_from_state(state, admin_user)
assert order.payment_method == cash_method
assert order.lines.count(
) == 5 # 2 submitted, two for the shipping and payment method, and a rounding line
assert order.creator == admin_user
assert order.customer == contact
assert order.taxful_total_price == shop.create_price(target)
def test_context_contact_group_condition():
rf = RequestFactory()
original_price_value, discount_value = 123, 15
request = get_request_for_contact_tests(rf)
customer = create_random_person()
default_group = get_default_customer_group()
customer.groups.add(default_group)
request.customer = customer
condition = ContactGroupCondition.objects.create()
condition.contact_groups.add(default_group)
product = create_random_product_and_campaign(request.shop, [condition],
original_price_value,
discount_value)
discounted_value = original_price_value - discount_value
assert_product_price_value_with_customer(request, customer, product,
discounted_value)
request.customer.groups.clear()
assert_product_price_value_with_customer(request, customer, product,
original_price_value)
def initialize_test(rf, include_tax=False):
activate("en")
shop = get_shop(prices_include_tax=include_tax)
shop.domain = "campaign"
shop.save()
# Valid baskets needs some payment methods to be available
get_payment_method(shop)
# Since some of the baskets are created for the default shop:
get_payment_method(None)
group = get_default_customer_group()
customer = create_random_person()
customer.groups.add(group)
customer.save()
request = rf.get("/")
request.shop = shop
request.META["HTTP_HOST"] = "campaign.shuup.com"
apply_request_middleware(request)
request.customer = customer
return request, shop, group
def test_order_creator_valid(rf, admin_user):
get_initial_order_status() # Needed for the API
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
order = get_order_from_state(get_frontend_order_state(contact), admin_user)
assert order.lines.count(
) == 5 # 3 submitted, two for the shipping and payment method
assert order.creator == admin_user
assert order.customer == contact
supplier = get_default_supplier()
for line in order.lines.all():
if line.type == OrderLineType.PRODUCT:
# Check that product line have right taxes
assert [line_tax.tax.code
for line_tax in line.taxes.all()] == ["test_code"]
assert line.taxful_price.amount > line.taxless_price.amount
if line.type not in {OrderLineType.PAYMENT, OrderLineType.SHIPPING}:
# Check that all of the lines that a supplier set, kept it.
assert line.supplier == supplier
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("shuup_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_product_visibility_change_basic(hide_unorderable_product):
"""
Make sure that the signal for hiding products when they become
unorderable is called on shop product save.
"""
if hide_unorderable_product:
# Connect signal to hide products when they become unorderable
stocks_updated.connect(receiver=shop_product_orderability_check,
dispatch_uid="shop_product_orderability_check")
shop = get_default_shop()
contact = create_random_person()
supplier = get_default_supplier()
product = create_product("test",
shop=shop,
supplier=supplier,
default_price=10)
shop_product = product.get_shop_instance(shop=shop)
assert shop_product.is_visible(contact)
assert shop_product.is_purchasable(supplier, contact, 1)
assert shop_product.is_orderable(supplier, contact, 1)
shop_product.purchasable = False
shop_product.save()
shop_product.refresh_from_db()
if hide_unorderable_product:
assert not shop_product.is_visible(contact)
assert not shop_product.is_purchasable(supplier, contact, 1)
assert not shop_product.is_orderable(supplier, contact, 1)
# Disconnect signal just in case...
stocks_updated.disconnect(
receiver=shop_product_orderability_check,
dispatch_uid="shop_product_orderability_check")
else:
assert shop_product.is_visible(
contact) # Still visible in front but not purchasable or orderable
assert not shop_product.is_purchasable(supplier, contact, 1)
assert not shop_product.is_orderable(supplier, contact, 1)
def test_protected_fields():
activate("en")
shop = Shop.objects.create(name="testshop",
identifier="testshop",
status=ShopStatus.ENABLED,
public_name="test shop",
domain="derp",
currency="EUR")
assert shop.name == "testshop"
assert shop.currency == "EUR"
assert not ConfigurationItem.objects.filter(shop=shop,
key="languages").exists()
shop_form = ShopBaseForm(instance=shop, languages=settings.LANGUAGES)
assert not shop_form._get_protected_fields(
) # No protected fields just yet, right?
data = get_form_data(shop_form, prepared=True)
shop_form = ShopBaseForm(data=data,
instance=shop,
languages=settings.LANGUAGES)
_test_cleanliness(shop_form)
shop_form.save()
# Now let's make it protected!
create_product(printable_gibberish(),
shop=shop,
supplier=get_default_supplier())
order = create_random_order(customer=create_random_person(), shop=shop)
assert order.shop == shop
# And try again...
data["currency"] = "USD"
shop_form = ShopBaseForm(data=data,
instance=shop,
languages=settings.LANGUAGES)
assert shop_form._get_protected_fields() # So protected!
_test_cleanliness(shop_form)
shop = shop_form.save()
assert shop.currency == "EUR" # But the shop form ignored the change . . .
def create_random_review_for_product(shop,
product,
reviewer=None,
order=None,
approved=True,
rating=None,
would_recommend=None,
generate_comment=True):
if reviewer is None:
reviewer = factories.create_random_person("en")
if order is None:
order = factories.create_order_with_product(
product=product,
supplier=factories.get_default_supplier(),
quantity=1,
taxless_base_unit_price=10,
shop=shop)
if rating is None:
rating = random.randint(1, 5)
if would_recommend is None:
would_recommend = random.choice([True, False])
comment = None
if generate_comment:
comment = Faker().text(100)
return ProductReview.objects.create(
shop=shop,
product=product,
reviewer=reviewer,
order=order,
rating=rating,
comment=comment,
would_recommend=would_recommend,
status=(ReviewStatus.APPROVED if approved else ReviewStatus.PENDING))
def test_mass_edit_orders4(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": OrderDeliveryPdfAction().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
assert response["content-type"] == "application/json"
order.create_shipment_of_all_products(supplier)
order.save()
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=shipment_%s_delivery.pdf' % order.pk
else:
assert response["content-type"] == "application/json"
def test_products_not_available_shop(admin_user):
shop1 = get_default_shop()
person1 = create_random_person()
person1.user = admin_user
person1.save()
supplier1 = create_simple_supplier("supplier1")
product1 = create_product("product1", shop=shop1, supplier=supplier1)
product3 = create_product("product3", shop=shop1, supplier=supplier1)
# add images for products 1 and 3
add_product_image(product1)
add_product_image(product3)
# product 3 not visible
shop1_product3 = ShopProduct.objects.get(shop=shop1, product=product3)
shop1_product3.visibility = ShopProductVisibility.NOT_VISIBLE
shop1_product3.save()
request = get_request("/api/shuup/front/shop_products/", admin_user, person1)
response = FrontShopProductViewSet.as_view({"get": "list"})(request)
response.render()
products_data = json.loads(response.content.decode("utf-8"))
assert len(products_data) == 1
# now product3 becomes visible
shop1_product3.visibility = ShopProductVisibility.ALWAYS_VISIBLE
shop1_product3.save()
request = get_request("/api/shuup/front/shop_products/", admin_user, person1)
response = FrontShopProductViewSet.as_view({"get": "list"})(request)
response.render()
products_data = json.loads(response.content.decode("utf-8"))
assert len(products_data) == 2
assert products_data[0]["is_orderable"] is True
assert products_data[1]["is_orderable"] is True
# check for images
assert products_data[0]["image"] == request.build_absolute_uri(product1.primary_image.url)
assert products_data[1]["image"] == request.build_absolute_uri(product3.primary_image.url)
def test_order_creator_customer_details(rf, admin_user):
shop = get_default_shop()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
company = create_random_company()
group = get_default_customer_group()
contact.groups.add(group)
contact.company_memberships.add(company)
contact.save()
product = create_product(
sku=printable_gibberish(),
supplier=get_default_supplier(),
shop=shop
)
order = create_random_order(contact, products=[product])
request = apply_request_middleware(rf.get("/", {
"command": "customer_details",
"id": contact.id
}), user=admin_user)
response = OrderEditView.as_view()(request)
data = json.loads(response.content.decode("utf8"))
assert "customer_info" in data
assert "order_summary" in data
assert "recent_orders" in data
assert data["customer_info"]["name"] == contact.full_name
assert data["customer_info"]["phone_no"] == contact.phone
assert data["customer_info"]["email"] == contact.email
assert company.full_name in data["customer_info"]["companies"]
assert group.name in data["customer_info"]["groups"]
assert data["customer_info"]["merchant_notes"] == contact.merchant_notes
assert len(data["order_summary"]) == 1
assert data["order_summary"][0]["year"] == order.order_date.year
assert data["order_summary"][0]["total"] == format_money(order.taxful_total_price)
assert len(data["recent_orders"]) == 1
assert data["recent_orders"][0]["status"] == order.get_status_display()
assert data["recent_orders"][0]["total"] == format_money(order.taxful_total_price)
assert data["recent_orders"][0]["payment_status"] == force_text(order.payment_status.label)
assert data["recent_orders"][0]["shipment_status"] == force_text(order.shipping_status.label)
def test_products_all_shops(admin_user):
shop1 = get_default_shop()
shop1.logo = get_random_filer_image()
shop1.save()
person1 = create_random_person()
person1.user = admin_user
person1.save()
shop2 = Shop.objects.create(status=ShopStatus.ENABLED)
shop2.favicon = get_random_filer_image()
shop2.save()
supplier1 = create_simple_supplier("supplier1")
supplier2 = create_simple_supplier("supplier2")
# create 2 products for shop2
product1 = create_product("product1", shop=shop1, supplier=supplier1)
product2 = create_product("product2", shop=shop2, supplier=supplier2)
product3 = create_product("product3", shop=shop2, supplier=supplier1)
# list all orderable products - 2 just created are for shop2
request = get_request("/api/shuup/front/shop_products/", admin_user, person1)
response = FrontShopProductViewSet.as_view({"get": "list"})(request)
response.render()
products = json.loads(response.content.decode("utf-8"))
assert len(products) == 3
assert products[0]["product_id"] == product1.id
assert products[0]["shop"]["id"] == shop1.id
assert products[0]["shop"]["logo"] == request.build_absolute_uri(shop1.logo.url)
assert products[1]["product_id"] == product2.id
assert products[1]["shop"]["id"] == shop2.id
assert products[1]["shop"]["favicon"] == request.build_absolute_uri(shop2.favicon.url)
assert products[2]["product_id"] == product3.id
assert products[2]["shop"]["id"] == shop2.id
assert products[2]["shop"]["favicon"] == request.build_absolute_uri(shop2.favicon.url)
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 test_order_edit_with_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)
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() == 4
assert OrderLineType.DISCOUNT in [l.type for l in edited_order.lines.all()]
assert edited_order.coupon_usages.count() == 1
def test_mass_edit_orders3(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")
order1 = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0)
order2 = create_random_order(customer=contact1, products=[product1, product2], completion_probability=0)
assert order1.status.role != OrderStatusRole.CANCELED
assert order2.status.role != OrderStatusRole.CANCELED
payload = {"action": OrderConfirmationPdfAction().identifier, "values": [order1.pk, order2.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_confirmation_pdf.zip"
else:
assert response["content-type"] == "application/json"
def test_contact_module_search_multishop(rf):
with override_settings(SHUUP_MANAGE_CONTACTS_PER_SHOP=True, SHUUP_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.add_to_shop(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_min_amount_is_not_included():
shop = get_default_shop()
supplier = get_default_supplier()
person = create_random_person()
initial_group_count = person.groups.count()
sales_ranges = [("silver", 0, 50), ("gold", 50, 100), ("diamond", 100, 1000), ("reverse_diamond", 1000, 100)]
for identifier, min, max in sales_ranges:
create_sales_range(identifier, shop, min, max)
payment = create_fully_paid_order(shop, person, supplier, "sku1", 50)
assert get_total_sales(shop, person) == 50
update_customers_groups(Payment, payment)
assert person.groups.count() == (initial_group_count + 1)
assert bool([group for group in person.groups.all() if group.identifier == "gold"])
assert not bool([group for group in person.groups.all() if group.identifier in ["silver", "diamond"]])
payment = create_fully_paid_order(shop, person, supplier, "sku2", 50)
assert get_total_sales(shop, person) == 100
update_customers_groups(Payment, payment)
assert person.groups.count() == (initial_group_count + 1)
assert bool([group for group in person.groups.all() if group.identifier == "diamond"])
assert not bool([group for group in person.groups.all() if group.identifier == "reverse_diamond"])
assert not bool([group for group in person.groups.all() if group.identifier in ["silver", "gold"]])
def test_get_products(admin_user):
shop = get_default_shop()
supplier = get_default_supplier()
person1 = create_random_person()
person1.user = admin_user
person1.save()
create_product("product1", shop=shop, supplier=supplier)
create_product("product2", shop=shop, supplier=supplier)
# Generate complex variations
product_parent = create_product("product3", shop=shop, supplier=supplier)
populate_variations_for_parent(product_parent, shop, supplier)
assert product_parent.mode == ProductMode.VARIABLE_VARIATION_PARENT
# Generate simple variations
simple_parent = create_product("product4", shop=shop, supplier=supplier)
simple_child = create_product("product5", shop=shop, supplier=supplier)
simple_child.link_to_parent(simple_parent)
assert simple_child.is_variation_child()
assert simple_parent.mode == ProductMode.SIMPLE_VARIATION_PARENT
request = get_request("/api/shuup/front/shop_products/", admin_user, person1)
response = FrontShopProductViewSet.as_view({"get": "list"})(request)
response.render()
assert response.status_code == status.HTTP_200_OK
products_data = json.loads(response.content.decode("utf-8"))
assert len(products_data) == 4
complex_parent_data = [data for data in products_data if data["product_id"] == product_parent.id][0]
assert len(complex_parent_data["variations"]) == 12
simple_parent_data = [data for data in products_data if data["product_id"] == simple_parent.id][0]
assert len(simple_parent_data["variations"]) == 1
assert simple_parent_data["variations"][0]["sku_part"] == simple_child.sku
assert simple_parent_data["variations"][0]["product"]["product_id"] == simple_child.id
def test_contact_company_edit_multishop(rf):
with override_settings(SHUUP_MANAGE_CONTACTS_PER_SHOP=True, SHUUP_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 = ContactEditView.as_view()
# permission denied for contact and shop1
request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop1)
with pytest.raises(PermissionDenied):
response = view(request, pk=contact.id)
# permission granted for contact and shop2
request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop2)
response = view(request, pk=contact.id)
assert response.status_code == 200
# permission denied for company and shop2
request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop2)
with pytest.raises(PermissionDenied):
response = view(request, pk=company.id)
# permission granted for company and shop1
request = apply_request_middleware(rf.get("/"), user=staff_user, shop=shop1)
response = view(request, pk=company.id)
assert response.status_code == 200
def test_user_detail_contact_seed(rf, admin_user):
get_default_shop()
contact = create_random_person()
# Using random data for name and email would need escaping when
# checking if it is rendered, therefore use something very basic instead
contact.name = "Matti Perustyyppi"
contact.email = "*****@*****.**"
contact.save()
view_func = UserDetailView.as_view()
# Check that fields populate . . .
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}),
user=admin_user)
response = view_func(request)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
# POST the password too to create the user . . .
post = extract_form_fields(BeautifulSoup(content))
post["password"] = "******"
request.method = "POST"
request.POST = post
response = view_func(request)
assert response.status_code < 500
# Check this new user is visible in the details now
user = Contact.objects.get(pk=contact.pk).user
request = apply_request_middleware(rf.get("/", {"contact_id": contact.pk}),
user=admin_user)
response = view_func(request, pk=user.pk)
response.render()
content = force_text(response.content)
assert force_text(contact.first_name) in content
assert force_text(contact.last_name) in content
assert force_text(contact.email) in content
def test_reviews_view_multiple_supplires(rf):
shop = factories.get_default_shop()
customer = factories.create_random_person("en")
user = factories.create_random_user("en")
user.set_password("user")
user.save()
customer.user = user
customer.save()
supplier1_name = "Supplier 1 name"
supplier1 = Supplier.objects.create(identifier="1", name=supplier1_name)
supplier1.shops.set([shop])
supplier2_name = "Supplier 2 name"
supplier2 = Supplier.objects.create(identifier="2", name=supplier2_name)
supplier2.shops.set([shop])
product = factories.create_product("test1",
shop=shop,
supplier=supplier1,
default_price=10)
shop_product = product.get_shop_instance(shop=shop)
assert shop_product.suppliers.filter(id=supplier1.id).exists()
shop_product.suppliers.add(supplier2)
assert shop_product.suppliers.filter(id=supplier2.id).exists()
create_multi_supplier_order_to_review(shop_product, customer)
client = SmartClient()
client.login(username=user.username, password="******")
response, soup = client.response_and_soup(reverse("shuup:vendor_reviews"))
assert "Vendors to Review" in soup.text
assert len(
soup.findAll("div",
attrs={"class": "vendors-to-review"})[0].findChildren(
"div", attrs={"class": "list-group-item"})) == 2
assert "%s" % supplier2_name in soup.text
assert "%s" % supplier1_name in soup.text
def test_contact_edit_multishop(rf):
with override_settings(SHUUP_MANAGE_CONTACTS_PER_SHOP=True,
SHUUP_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)
contact = create_random_person(locale="en_US",
minimum_name_comp_len=5,
shop=shop2)
# only available in shop2
assert contact.registered_in(shop2)
assert contact.in_shop(shop2)
request = apply_request_middleware(rf.get("/"),
user=staff_user,
shop=shop1)
view = ContactDetailView.as_view()
# contact not found for this shop
with pytest.raises(Http404):
response = view(request, pk=contact.id)
request = apply_request_middleware(rf.get("/"),
user=staff_user,
shop=shop2)
response = view(request, pk=contact.id)
assert response.status_code == 200
assert contact.registered_in(shop2)
assert contact.in_shop(shop2)
assert not contact.registered_in(shop1)
assert not contact.in_shop(shop1)
def test_simple_supplier_out_of_stock(rf, anonymous):
supplier = get_simple_supplier()
shop = get_default_shop()
product = create_product("simple-test-product", shop, supplier, stock_behavior=StockBehavior.STOCKED)
if anonymous:
customer = AnonymousContact()
else:
customer = create_random_person()
ss = supplier.get_stock_status(product.pk)
assert ss.product == product
assert ss.logical_count == 0
num = random.randint(100, 500)
supplier.adjust_stock(product.pk, +num)
assert supplier.get_stock_status(product.pk).logical_count == num
shop_product = product.get_shop_instance(shop)
assert shop_product.is_orderable(supplier, customer, 1)
# Create order
order = create_order_with_product(product, supplier, num, 3, shop=shop)
order.get_product_ids_and_quantities()
pss = supplier.get_stock_status(product.pk)
assert pss.logical_count == 0
assert pss.physical_count == num
assert not shop_product.is_orderable(supplier, customer, 1)
# Create shipment
shipment = order.create_shipment_of_all_products(supplier)
assert isinstance(shipment, Shipment)
pss = supplier.get_stock_status(product.pk)
assert pss.logical_count == 0
assert pss.physical_count == 0
assert not shop_product.is_orderable(supplier, customer, 1)
def test_filter_parameter_contact_groups():
(engine, context) = _get_template_engine_and_context()
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):
# 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)
# 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_coupon_user_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(shop), default_price="12")
order = create_random_order(customer=contact)
for x in range(50):
coupon.use(order)
assert coupon.usages.count() == 50
# set limit to coupon_usage
coupon.increase_customer_usage_limit_by(5)
coupon.save()
assert coupon.usage_limit_customer == 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_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_order_creator_view_2(browser, admin_user, live_server, settings):
shop = get_default_shop()
pm = get_default_payment_method()
sm = get_default_shipping_method()
get_initial_order_status()
supplier = get_default_supplier()
person = create_random_person()
create_product("test-sku0", shop=shop, default_price=10, supplier=supplier)
create_product("test-sku1", shop=shop, default_price=10, supplier=supplier)
object_created.connect(_add_custom_order_created_message,
sender=Order,
dispatch_uid="object_created_signal_test")
initialize_admin_browser_test(browser, live_server, settings)
browser.driver.set_window_size(1920, 1080)
_visit_order_creator_view(browser, live_server)
_test_customer_using_search(browser, person)
_test_add_lines(browser)
_test_methods(browser, sm, pm)
_test_confirm(browser)
assert Order.objects.first().log_entries.filter(
identifier=OBJECT_CREATED_LOG_IDENTIFIER).count() == 1
object_created.disconnect(sender=Order,
dispatch_uid="object_created_signal_test")
def setUp(self):
OrderStatusManager().ensure_default_statuses()
product = factories.create_product("p", factories.get_default_shop(), factories.get_default_supplier())
customer = factories.create_random_person()
# Initial Order
intial_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.INITIAL.value).first()
self.order_initial = factories.create_random_order(customer=customer, products=[product])
self.order_initial.change_status(intial_status)
# Processing Order
process_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.PROCESSING.value).first()
self.order_processing = factories.create_random_order(customer=customer, products=[product])
self.order_processing.change_status(process_status)
# Complete Order
complete_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.COMPLETE.value).first()
self.order_complete = factories.create_random_order(customer=customer, products=[product])
self.order_complete.change_status(complete_status)
# Canceled Order
canceled_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.CANCELED.value).first()
self.order_canceled = factories.create_random_order(customer=customer, products=[product])
self.order_canceled.change_status(canceled_status)
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("shuup_admin:gdpr.anonymize",
kwargs=dict(pk=person.pk))
response = client.post(admin_anonymize_url)
assert response.status_code == 302
assert response.url.endswith(
reverse("shuup_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_order_creator_view(browser, admin_user, live_server):
shop = get_default_shop()
pm = get_default_payment_method()
sm = get_default_shipping_method()
get_initial_order_status()
supplier = get_default_supplier()
person = create_random_person()
product0 = create_product("test-sku0",
shop=shop,
default_price=10,
supplier=supplier)
product1 = create_product("test-sku1",
shop=shop,
default_price=10,
supplier=supplier)
initialize_admin_browser_test(browser, live_server)
_visit_order_creator_view(browser, live_server)
_test_language_change(browser)
_test_customer_data(browser, person)
_test_add_lines(browser)
_test_quick_add_lines(browser)
_test_methods(browser)
_test_confirm(browser)
