def test_single_page_checkout_with_login_and_register(browser, live_server,
settings):
cache.clear() # Avoid caches from past tests
# initialize
product_name = "Test Product"
get_default_shop()
get_default_payment_method()
get_default_shipping_method()
product = create_orderable_product(product_name, "test-123", price=100)
OrderStatus.objects.create(identifier="initial",
role=OrderStatusRole.INITIAL,
name="initial",
default=True)
# Initialize test and go to front page
browser = initialize_front_browser_test(browser, live_server)
wait_until_condition(browser,
lambda x: x.is_text_present("Welcome to Default!"))
navigate_to_checkout(browser, product)
# Let's assume that after addresses the checkout is normal
wait_until_condition(browser,
lambda x: x.is_text_present("Checkout Method"))
test_username = "******"
test_email = "*****@*****.**"
test_password = "******"
register_test(browser, live_server, test_username, test_email,
test_password)
login_and_finish_up_the_checkout(browser, live_server, test_username,
test_email, test_password)
def test_basket(rf):
StoredBasket.objects.all().delete()
quantities = [3, 12, 44, 23, 65]
shop = get_default_shop()
get_default_payment_method(
) # Can't create baskets without payment methods
supplier = get_default_supplier()
products_and_quantities = []
for quantity in quantities:
product = create_product(printable_gibberish(),
shop=shop,
supplier=supplier,
default_price=50)
products_and_quantities.append((product, quantity))
for product, q in products_and_quantities:
request = rf.get("/")
request.session = {}
request.shop = shop
apply_request_middleware(request)
basket = get_basket(request)
assert basket == request.basket
assert basket.product_count == 0
line = basket.add_product(supplier=supplier,
shop=shop,
product=product,
quantity=q)
basket.shipping_method = get_shipping_method(
shop=shop) # For shippable product
assert line.quantity == q
assert basket.get_lines()
assert basket.get_product_ids_and_quantities().get(product.pk) == q
assert basket.product_count == q
basket.save()
delattr(request, "basket")
basket = get_basket(request)
assert basket.get_product_ids_and_quantities().get(product.pk) == q
product_ids = set(StoredBasket.objects.last().products.values_list(
"id", flat=True))
assert product_ids == set([product.pk])
stats = StoredBasket.objects.all().aggregate(
n=Sum("product_count"),
tfs=Sum("taxful_total_price_value"),
tls=Sum("taxless_total_price_value"),
)
assert stats["n"] == sum(quantities)
if shop.prices_include_tax:
assert stats["tfs"] == sum(quantities) * 50
else:
assert stats["tls"] == sum(quantities) * 50
basket.finalize()
def create_simple_order(request, creator, customer):
billing_address = get_address().to_immutable()
shipping_address = get_address(name="Shippy Doge").to_immutable()
shipping_address.save()
shop = request.shop
order = Order(
creator=creator,
customer=customer,
shop=shop,
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=billing_address,
shipping_address=shipping_address,
order_date=now(),
status=get_initial_order_status(),
currency=shop.currency,
prices_include_tax=shop.prices_include_tax,
)
order.full_clean()
order.save()
order.cache_prices()
order.check_all_verified()
order.save()
return order
def seed_source(user, shop):
source = BasketishOrderSource(shop)
source.status = get_initial_order_status()
source.customer = get_person_contact(user)
source.payment_method = get_default_payment_method()
source.shipping_method = get_default_shipping_method()
return source
def test_basket_clearing(rf):
StoredBasket.objects.all().delete()
shop = get_default_shop()
supplier = get_default_supplier()
product = create_product(printable_gibberish(),
shop=shop,
supplier=supplier,
default_price=50)
request = rf.get("/")
request.session = {}
request.shop = shop
apply_request_middleware(request)
basket = get_basket(request)
pm = get_default_payment_method()
sm = get_default_shipping_method()
basket.shipping_method = sm
basket.payment_method = pm
basket.save()
assert basket.shipping_method
assert basket.payment_method
basket.clear_all()
assert not basket.shipping_method
assert not basket.payment_method
def test_unsaved_contact(admin_user):
payment_method = get_default_payment_method()
_assign_component_for_service(payment_method, [PersonContact.get_default_group()])
person = PersonContact(name="Kalle")
source = _get_source_for_contact(admin_user, payment_method)
source.customer = person
assert not person.pk and not source.customer.pk
_test_service_availability(source, payment_method, False)
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_order_creator_view_1(browser, admin_user, live_server, settings):
shop = get_default_shop()
get_default_payment_method()
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)
_visit_order_creator_view(browser, live_server)
_test_language_change(browser)
_test_customer_data(browser, person)
_test_regions(browser, person)
_test_quick_add_lines(browser)
def test_coupon(browser, live_server, settings):
activate("en")
# initialize
cache.clear()
shop = get_default_shop()
get_default_payment_method()
get_default_shipping_method()
first_category = Category.objects.create(identifier="cat-1",
status=CategoryStatus.VISIBLE,
name="First Category")
first_category.shops.add(shop)
_populate_products_form_data(CATEGORY_PRODUCT_DATA, shop, first_category)
# initialize test and go to front page
browser = initialize_front_browser_test(browser, live_server)
_add_product_to_basket_from_category(live_server, browser, first_category,
shop)
_activate_basket_campaign_through_coupon(browser, first_category, shop)
def test_with_multiple_groups(admin_user):
payment_method = get_default_payment_method()
group = get_default_customer_group()
person = create_random_person()
groups = [group, person.get_default_group()]
_assign_component_for_service(payment_method, groups)
person.user = admin_user
person.save()
source = _get_source_for_contact(admin_user, payment_method)
assert source.customer == person
assert len([group for group in person.groups.all() if group in groups]) == 1
_test_service_availability(source, payment_method, True)
def _save_cart_with_products(rf, user):
shop = get_default_shop()
person = get_person_contact(user)
get_default_payment_method()
get_default_shipping_method()
request = rf.post("/", {"title": "test"})
request.shop = shop
request.user = user
request.person = person
request.customer = person
basket = get_basket(request)
request = apply_request_middleware(request,
user=user,
person=person,
customer=person,
basket=basket)
basket = _add_products_to_basket(basket)
basket.save()
response = CartSaveView.as_view()(request)
basket = StoredBasket.objects.filter(title="test").first()
data = json.loads(response.content.decode("utf8"))
assert data["ok"], "cart saved successfully"
return basket
def test_contact_group_behavior(admin_user):
payment_method = get_default_payment_method()
group = get_default_customer_group()
_assign_component_for_service(payment_method, [group])
person = create_random_person()
person.user = admin_user
person.save()
source = _get_source_for_contact(admin_user, payment_method)
assert source.customer == person
assert group not in person.groups.all()
_test_service_availability(source, payment_method, False)
person.groups.add(group)
assert group in person.groups.all()
_test_service_availability(source, payment_method, True)
def test_create_without_a_contact(admin_user):
create_default_order_statuses()
shop = get_default_shop()
sm = get_default_shipping_method()
pm = get_default_payment_method()
assert not Order.objects.count()
client = _get_client(admin_user)
lines = [
{
"type": "other",
"sku": "hello",
"text": "A greeting",
"quantity": 1,
"base_unit_price_value": "3.5"
},
]
response = client.post("/api/wshop/order/",
content_type="application/json",
data=json.dumps({
"shop": shop.pk,
"customer": None,
"shipping_method": sm.pk,
"payment_method": pm.pk,
"lines": lines
}))
assert response.status_code == 201
assert Order.objects.count() == 1
order = Order.objects.first()
assert order.shop == shop
assert order.customer == None
assert order.creator == admin_user
assert order.shipping_method == sm
assert order.payment_method == pm
assert order.billing_address == None
assert order.shipping_address == None
assert order.payment_status == PaymentStatus.NOT_PAID
assert order.shipping_status == ShippingStatus.NOT_SHIPPED
assert order.status == OrderStatus.objects.get_default_initial()
assert order.taxful_total_price_value == decimal.Decimal(3.5)
assert order.lines.count(
) == 3 # shipping line, payment line, 2 product lines, 2 other lines
for idx, line in enumerate(order.lines.all()[:1]):
assert line.quantity == decimal.Decimal(lines[idx].get("quantity"))
assert line.base_unit_price_value == decimal.Decimal(lines[idx].get(
"base_unit_price_value", 0))
assert line.discount_amount_value == decimal.Decimal(lines[idx].get(
"discount_amount_value", 0))
def get_order_and_source(admin_user, product, language, language_fallback):
# create original source to tamper with
contact = get_person_contact(admin_user)
contact.language = language
contact.save()
assert contact.language == language # contact language is naive
source = BasketishOrderSource(get_default_shop())
source.status = get_initial_order_status()
source.billing_address = MutableAddress.objects.create(
name="Original Billing")
source.shipping_address = MutableAddress.objects.create(
name="Original Shipping")
source.customer = contact
source.payment_method = get_default_payment_method()
source.shipping_method = get_default_shipping_method()
source.add_line(
type=OrderLineType.PRODUCT,
product=product,
supplier=get_default_supplier(),
quantity=1,
base_unit_price=source.create_price(10),
)
source.add_line(
type=OrderLineType.OTHER,
quantity=1,
base_unit_price=source.create_price(10),
require_verification=True,
)
assert len(source.get_lines()) == 2
source.creator = admin_user
assert not source._language # is None because it was not directly assigned
assert source.language == language_fallback
creator = OrderCreator()
order = creator.create_order(source)
assert order.language == source.language
return order, source
def seed_source(coupon, produce_price=10):
source = BasketishOrderSource(get_default_shop())
billing_address = get_address()
shipping_address = get_address(name="Shippy Doge")
source.status = get_initial_order_status()
source.billing_address = billing_address
source.shipping_address = shipping_address
source.customer = create_random_person()
source.payment_method = get_default_payment_method()
source.shipping_method = get_default_shipping_method()
source.add_line(
type=OrderLineType.PRODUCT,
product=get_default_product(),
supplier=get_default_supplier(),
quantity=1,
base_unit_price=source.create_price(produce_price),
)
source.add_code(coupon.code)
return source
def test_staff_only_behavior(admin_user, regular_user):
payment_method = get_default_payment_method()
component = StaffOnlyBehaviorComponent.objects.create()
payment_method.behavior_components.add(component)
source = BasketishOrderSource(get_default_shop())
# anonymous user
unavailability_reasons = list(
payment_method.get_unavailability_reasons(source))
assert len(unavailability_reasons) == 1
# regular user
source.creator = regular_user
unavailability_reasons = list(
payment_method.get_unavailability_reasons(source))
assert len(unavailability_reasons) == 1
# admin
source.creator = admin_user
unavailability_reasons = list(
payment_method.get_unavailability_reasons(source))
assert len(unavailability_reasons) == 0
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 test_create_order(admin_user, target_customer):
with override_settings(**REQUIRED_SETTINGS):
set_configuration()
factories.create_default_order_statuses()
shop = factories.get_default_shop()
client = _get_client(admin_user)
# Create basket for target customer
payload = {"shop": shop.pk}
target = orderer = get_person_contact(admin_user)
if target_customer == "other_person":
target = orderer = factories.create_random_person()
payload["customer"] = target.pk
elif target_customer == "company":
target = factories.create_random_company()
orderer = factories.create_random_person()
payload.update({"customer": target.pk, "orderer": orderer.pk})
target.members.add(orderer)
response = client.post("/api/wshop/basket/new/", payload)
assert response.status_code == status.HTTP_201_CREATED
basket_data = json.loads(response.content.decode("utf-8"))
basket = Basket.objects.first()
assert basket.key == basket_data["uuid"].split("-")[1]
assert basket.customer == target
assert basket.orderer == orderer
shop_product = factories.get_default_shop_product()
shop_product.default_price = TaxfulPrice(1, shop.currency)
shop_product.save()
# Add shop product to basket
payload = {"shop_product": shop_product.id}
response = client.post(
"/api/wshop/basket/{}-{}/add/".format(shop.pk, basket.key),
payload)
assert response.status_code == status.HTTP_200_OK
response_data = json.loads(response.content.decode("utf-8"))
assert len(response_data["items"]) == 1
# Create order from basket
response = client.post(
"/api/wshop/basket/{}-{}/create_order/".format(
shop.pk, basket.key), payload)
assert response.status_code == status.HTTP_400_BAD_REQUEST
response_data = json.loads(response.content.decode("utf-8"))
assert "errors" in response_data
factories.get_default_payment_method()
factories.get_default_shipping_method()
response = client.post(
"/api/wshop/basket/{}-{}/create_order/".format(
shop.pk, basket.key), payload)
assert response.status_code == status.HTTP_201_CREATED
response_data = json.loads(response.content.decode("utf-8"))
basket.refresh_from_db()
assert basket.finished
order = Order.objects.get(
reference_number=response_data["reference_number"])
assert order.status == OrderStatus.objects.get_default_initial()
assert order.payment_status == PaymentStatus.NOT_PAID
assert order.shipping_status == ShippingStatus.NOT_SHIPPED
assert not order.payment_method
assert not order.shipping_method
assert float(order.taxful_total_price_value) == 1
assert order.customer == target
assert order.orderer == orderer
assert order.creator == admin_user
assert not order.billing_address
assert not order.shipping_address
def test_basket_reorder_staff_user():
with override_settings(**REQUIRED_SETTINGS):
set_configuration()
shop = factories.get_default_shop()
factories.get_default_payment_method()
factories.get_default_shipping_method()
staff_user = User.objects.create(username="******", is_staff=True)
client = _get_client(staff_user)
person = factories.create_random_person()
# create an order for the person
product = create_product("product",
shop=shop,
supplier=get_default_supplier(),
default_price='12.4')
order = create_random_order(customer=person,
products=[product],
completion_probability=1,
shop=shop)
# create the basket
response = client.post("/api/wshop/basket/new/",
data={
"shop": shop.pk,
"customer": person.pk
},
format="json")
# Only stuff linked to shop can create baskets for someone else
assert response.status_code == status.HTTP_403_FORBIDDEN
# Can still add personal baskets
staff_person = get_person_contact(staff_user)
response = client.post("/api/wshop/basket/new/",
data={
"shop": shop.pk,
"customer": staff_person.pk
},
format="json")
assert response.status_code == status.HTTP_201_CREATED
basket_data = json.loads(response.content.decode("utf-8"))
basket = Basket.objects.filter(
key=basket_data["uuid"].split("-")[1]).first()
assert basket.shop == shop
assert basket.creator == staff_user
assert basket.customer.pk == staff_person.pk
response = client.get("/api/wshop/basket/{}/".format(
basket_data["uuid"]))
assert response.status_code == 200
# Ok let's link the staff member to the shop and
# the basket create for random person should work
shop.staff_members.add(staff_user)
response = client.post("/api/wshop/basket/new/",
data={
"shop": shop.pk,
"customer": person.pk
},
format="json")
assert response.status_code == status.HTTP_201_CREATED
basket_data = json.loads(response.content.decode("utf-8"))
basket = Basket.objects.filter(
key=basket_data["uuid"].split("-")[1]).first()
assert basket.shop == shop
assert basket.creator == staff_user
assert basket.customer.pk == person.pk
response = client.get("/api/wshop/basket/{}/".format(
basket_data["uuid"]))
assert response.status_code == 200
assert basket.creator == staff_user
assert basket.customer.pk == person.pk
# add contents to the basket from a customer order
response = client.post(
'/api/wshop/basket/{}-{}/add_from_order/'.format(
shop.pk, basket.key),
data={"order": order.pk},
format="json")
assert response.status_code == status.HTTP_200_OK
basket_data = json.loads(response.content.decode("utf-8"))
assert len(basket_data['items']) > 0
assert Decimal(basket_data['taxful_total_price']
) == order.taxful_total_price_value
# finally create the order
response = client.post('/api/wshop/basket/{}-{}/create_order/'.format(
shop.pk, basket.key))
assert response.status_code == status.HTTP_201_CREATED
response_data = json.loads(response.content.decode("utf-8"))
created_order = Order.objects.get(id=response_data['id'])
assert created_order.creator == staff_user
assert created_order.customer == person
# create a second customer
person2 = factories.create_random_person()
# create a basket for customer 2 and try to fill with contents of customer 1 order - it should not be possible
response = client.post("/api/wshop/basket/new/",
data={
"shop": shop.pk,
"customer": person2.pk
},
format="json")
assert response.status_code == status.HTTP_201_CREATED
basket_data = json.loads(response.content.decode("utf-8"))
basket = Basket.objects.filter(
key=basket_data["uuid"].split("-")[1]).first()
assert basket.shop == shop
assert basket.creator == staff_user
assert basket.customer.pk == person2.pk
# add contents to the basket from customer 1 order - error
response = client.post(
'/api/wshop/basket/{}-{}/add_from_order/'.format(
shop.pk, basket.key),
data={"order": order.pk},
format="json")
assert response.status_code == status.HTTP_404_NOT_FOUND
assert 'invalid order' in response.content.decode("utf-8")
def test_encode_method_weights():
payment_method = get_default_payment_method()
assert encode_method(payment_method).get("minWeight") is None
shipping_method = get_default_shipping_method()
assert encode_method(shipping_method).get("minWeight") is None
def test_basket_with_package_product(admin_user):
with override_settings(**REQUIRED_SETTINGS):
shop = factories.get_default_shop()
factories.get_default_shipping_method()
factories.get_default_payment_method()
OrderStatusManager().ensure_default_statuses()
client = get_client(admin_user)
response = client.post("/api/wshop/basket/new/",
format="json",
data={"shop": shop.pk})
assert response.status_code == status.HTTP_201_CREATED
basket_uuid = response.data["uuid"]
supplier = factories.get_supplier(SimpleSupplierModule.identifier,
shop=shop)
# base product - 1kg of sand
base_sand_product = factories.create_product(
"Sand",
shop=shop,
supplier=supplier,
default_price="15.2",
net_weight=Decimal(1),
stock_behavior=StockBehavior.STOCKED)
# 10kg bag of sand - package made by 10kg of sand
sand_bag_10kg_product = factories.create_product(
"Sand-bag-10-kg",
shop=shop,
supplier=supplier,
default_price="149.9",
net_weight=Decimal(10000))
sand_bag_10kg_product.make_package({base_sand_product: 10})
sand_bag_10kg_product.save()
# 18.45kg bag of sand - package made by 18.45kg of sand
sand_bag_1845kg_product = factories.create_product(
"Sand-bag-1845-kg",
shop=shop,
supplier=supplier,
default_price="179.9",
net_weight=Decimal(18450))
sand_bag_1845kg_product.make_package({base_sand_product: 18.45})
sand_bag_1845kg_product.save()
# 25kg bag of sand - package made by 25kg of sand
sand_bag_25kg_product = factories.create_product(
"Sand-bag-25-kg",
shop=shop,
supplier=supplier,
default_price="2450.25",
net_weight=Decimal(25000))
sand_bag_25kg_product.make_package({base_sand_product: 25})
sand_bag_25kg_product.save()
initial_stock = 55
# put 55 sands (55kg) in stock
supplier.adjust_stock(base_sand_product.id, initial_stock)
stock_status = supplier.get_stock_status(base_sand_product.id)
assert stock_status.physical_count == initial_stock
assert stock_status.logical_count == initial_stock
# zero stock for packages
assert supplier.get_stock_status(
sand_bag_10kg_product.id).logical_count == 0
assert supplier.get_stock_status(
sand_bag_1845kg_product.id).logical_count == 0
assert supplier.get_stock_status(
sand_bag_25kg_product.id).logical_count == 0
# add all the 3 packages to the basket, this will require (10 + 18.45 + 25 = 53.45 Sands)
for product in [
sand_bag_10kg_product, sand_bag_1845kg_product,
sand_bag_25kg_product
]:
response = client.post(
"/api/wshop/basket/{}/add/".format(basket_uuid),
format="json",
data={
"shop": shop.pk,
"product": product.id
})
assert response.status_code == status.HTTP_200_OK
# get the basket
response = client.get("/api/wshop/basket/{}/".format(basket_uuid))
assert response.status_code == status.HTTP_200_OK
assert response.data["validation_errors"] == []
# now add more 25kg and it shouldn't have enough stock
response = client.post("/api/wshop/basket/{}/add/".format(basket_uuid),
format="json",
data={
"shop": shop.pk,
"product": sand_bag_25kg_product.id
})
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert "Insufficient stock" in response.data["error"]
# create order anyway
response = client.post(
"/api/wshop/basket/{}/create_order/".format(basket_uuid),
format="json")
assert response.status_code == status.HTTP_201_CREATED
order = Order.objects.get(id=response.data["id"])
line_counter = Counter()
for line in order.lines.products():
line_counter[line.product.id] += line.quantity
assert bankers_round(
line_counter[base_sand_product.id]) == bankers_round(
Decimal(10) + Decimal(18.45) + Decimal(25))
assert line_counter[sand_bag_10kg_product.id] == 1
assert line_counter[sand_bag_1845kg_product.id] == 1
assert line_counter[sand_bag_25kg_product.id] == 1
def test_model_form_partially_translated(rf, admin_user):
with override_settings(
**{
"LANGUAGES": (("en", "en"), ("fi", "fi"), ("ja", "ja")),
"PARLER_DEFAULT_LANGUAGE_CODE": "en"
}):
activate("en")
get_default_shop()
request = apply_request_middleware(rf.get("/"), user=admin_user)
test_name_en = "Test shop"
payment_method = get_default_payment_method()
payment_method.name = test_name_en
payment_method.save()
form = PaymentMethodForm(instance=payment_method,
request=request,
languages=settings.LANGUAGES)
data = get_form_data(form, prepared=True)
assert data.get("name__en") == test_name_en
assert not data.get("name__fi")
form = PaymentMethodForm(data=data,
instance=payment_method,
request=request,
languages=settings.LANGUAGES)
form.full_clean()
assert form.is_valid() and not form.errors
payment_method = form.save()
# Add description for Finnish and and name in Finnish should be required
data["description__fi"] = "Some description"
form = PaymentMethodForm(data=data,
instance=payment_method,
request=request,
languages=settings.LANGUAGES)
form.full_clean()
assert not form.is_valid() and form.errors
test_name_fi = "Some method name in finnish"
data["name__fi"] = test_name_fi
form = PaymentMethodForm(data=data,
instance=payment_method,
request=request,
languages=settings.LANGUAGES)
form.full_clean()
assert form.is_valid() and not form.errors
payment_method = form.save()
assert payment_method.name == test_name_en, "Object in English"
activate("fi")
payment_method.set_current_language("fi")
assert payment_method.name == test_name_fi, "Object in Finnish"
activate("ja")
payment_method.set_current_language("ja")
assert payment_method.name == test_name_en, "Should fallback to English"
# Check that no sneaky translations is not created for Japan
with pytest.raises(ObjectDoesNotExist):
translation = payment_method.get_translation("ja")
translation.refresh_from_db(
) # Just in case if the translation object comes from cache or something
# Empty finnish translations and see if Finnish starts fallbacks too
data["name__fi"] = data["description__fi"] = ""
form = PaymentMethodForm(data=data,
instance=payment_method,
request=request,
languages=settings.LANGUAGES)
form.full_clean()
assert form.is_valid() and not form.errors
form.save()
# Check that no sneaky translations is not created for Finnish
with pytest.raises(ObjectDoesNotExist):
translation = payment_method.get_translation("fi")
translation.refresh_from_db(
) # Just in case if the translation object comes from cache or something
def test_broken_order(admin_user):
"""
"""
quantities = [44, 23, 65]
expected = sum(quantities) * 50
expected_based_on = expected / 1.5
# Wshop is calculating taxes per line so there will be some "errors"
expected_based_on = ensure_decimal_places(
Decimal("%s" % (expected_based_on + 0.01)))
shop = get_default_shop()
supplier = get_default_supplier()
product1 = create_product("simple-test-product1", shop, supplier, 50)
product2 = create_product("simple-test-product2", shop, supplier, 50)
product3 = create_product("simple-test-product3", shop, supplier, 50)
tax = get_default_tax()
source = BasketishOrderSource(get_default_shop())
billing_address = get_address(country="US")
shipping_address = get_address(name="Test street", country="US")
source.status = get_initial_order_status()
source.billing_address = billing_address
source.shipping_address = shipping_address
source.customer = create_random_person()
source.payment_method = get_default_payment_method()
source.shipping_method = get_default_shipping_method()
source.add_line(
type=OrderLineType.PRODUCT,
product=product1,
supplier=get_default_supplier(),
quantity=quantities[0],
base_unit_price=source.create_price(50),
)
source.add_line(
type=OrderLineType.PRODUCT,
product=product2,
supplier=get_default_supplier(),
quantity=quantities[1],
base_unit_price=source.create_price(50),
)
source.add_line(
type=OrderLineType.PRODUCT,
product=product3,
supplier=get_default_supplier(),
quantity=quantities[2],
base_unit_price=source.create_price(50),
)
currency = "EUR"
summary = source.get_tax_summary()
assert len(summary) == 1
summary = summary[0]
assert summary.taxful == Money(expected, "EUR")
assert summary.based_on == Money(expected_based_on, "EUR")
# originally non-rounded value
assert bankers_round(source.get_total_tax_amount()) == summary.tax_amount
assert source.taxless_total_price.value == expected_based_on
assert summary.taxful.value == source.taxful_total_price.value
assert summary.tax_amount == Money(
bankers_round(source.taxful_total_price.value -
source.taxless_total_price.value), currency)
assert summary.taxful == summary.raw_based_on + summary.tax_amount
assert summary.tax_rate == tax.rate
assert summary.taxful.value == (
summary.based_on + summary.tax_amount).value - Decimal("%s" % 0.01)
# create order from basket
creator = OrderCreator()
order = creator.create_order(source)
assert order.taxless_total_price.value == expected_based_on
# originally non-rounded value
assert bankers_round(order.get_total_tax_amount()) == summary.tax_amount
def create_order(request, creator, customer, product):
billing_address = get_address().to_immutable()
shipping_address = get_address(name="Shippy Doge").to_immutable()
shipping_address.save()
default_pm = get_default_payment_method()
default_sm = get_default_shipping_method()
shop = request.shop
order = Order(
creator=creator,
customer=customer,
shop=shop,
payment_method=default_pm,
shipping_method=default_sm,
billing_address=billing_address,
shipping_address=shipping_address,
order_date=now(),
status=get_initial_order_status(),
currency=shop.currency,
prices_include_tax=shop.prices_include_tax,
)
order.full_clean()
order.save()
supplier = get_default_supplier()
product_order_line = OrderLine(order=order)
update_order_line_from_product(
pricing_context=request,
order_line=product_order_line,
product=product,
quantity=5,
supplier=supplier)
assert product_order_line.text == product.safe_translation_getter("name")
product_order_line.base_unit_price = shop.create_price(100)
assert product_order_line.price.value > 0
product_order_line.save()
line_tax = get_line_taxes_for(product_order_line)[0]
order_line_tax = OrderLineTax.from_tax(
tax=line_tax.tax,
base_amount=line_tax.base_amount,
order_line=product_order_line,
)
order_line_tax.save() # Save order_line_tax before linking to order_line.tax
product_order_line.taxes.add(order_line_tax)
discount_order_line = OrderLine(order=order, quantity=1, type=OrderLineType.OTHER)
discount_order_line.discount_amount = shop.create_price(30)
assert discount_order_line.discount_amount.value == 30
assert discount_order_line.price.value == -30
assert discount_order_line.base_unit_price.value == 0
discount_order_line.save()
order.cache_prices()
order.check_all_verified()
order.save()
assert not order.can_set_complete()
base = 5 * shop.create_price(100).amount
discount = shop.create_price(30).amount
tax_value = line_tax.amount
if not order.prices_include_tax:
assert order.taxless_total_price.amount == base - discount
assert order.taxful_total_price.amount == base + tax_value - discount
else:
assert_almost_equal(order.taxless_total_price.amount, base - tax_value - discount)
assert_almost_equal(order.taxful_total_price.amount, base - discount)
assert not order.is_fully_shipped()
shipment = order.create_shipment_of_all_products(supplier=supplier)
assert order.is_fully_shipped()
assert shipment.total_products == 5, "All products were shipped"
assert shipment.weight == product.gross_weight * 5 / 1000, "Gravity works"
assert not order.get_unshipped_products(), "Nothing was left in the warehouse"
assert order.can_set_complete()
order.create_payment(order.taxful_total_price)
assert order.is_paid()
assert Order.objects.paid().filter(pk=order.pk).exists(), "It was paid! Honestly!"
assert order.has_products()
assert order.get_available_shipping_methods()
assert order.get_available_payment_methods()
assert default_sm in order.get_available_shipping_methods()
assert default_pm in order.get_available_payment_methods()
def get_frontend_order_state(contact, valid_lines=True):
"""
Get a dict structure mirroring what the frontend JavaScript would submit.
:type contact: Contact|None
"""
translation.activate("en")
shop = get_default_shop()
tax, created = Tax.objects.get_or_create(code="test_code",
defaults={
"rate":
decimal.Decimal("0.20"),
"name": "Default"
})
tax_class, created = TaxClass.objects.get_or_create(
identifier="test_tax_class", defaults={"name": "Default"})
rule, created = TaxRule.objects.get_or_create(tax=tax)
rule.tax_classes.add(tax_class)
rule.save()
product = create_product(sku=printable_gibberish(),
supplier=get_default_supplier(),
shop=shop)
product.tax_class = tax_class
product.save()
if valid_lines:
lines = [
{
"id": "x",
"type": "product",
"product": {
"id": product.id
},
"quantity": "32",
"baseUnitPrice": 50
},
{
"id": "y",
"type": "other",
"sku": "hello",
"text": "A greeting",
"quantity": 1,
"unitPrice": "5.5"
},
{
"id": "z",
"type": "text",
"text": "This was an order!",
"quantity": 0
},
]
else:
unshopped_product = create_product(sku=printable_gibberish(),
supplier=get_default_supplier())
not_visible_product = create_product(sku=printable_gibberish(),
supplier=get_default_supplier(),
shop=shop)
not_visible_shop_product = not_visible_product.get_shop_instance(shop)
not_visible_shop_product.visibility = ShopProductVisibility.NOT_VISIBLE
not_visible_shop_product.save()
lines = [
{
"id": "x",
"type": "product"
}, # no product?
{
"id": "x",
"type": "product",
"product": {
"id": unshopped_product.id
}
}, # not in this shop?
{
"id": "y",
"type": "product",
"product": {
"id": -product.id
}
}, # invalid product?
{
"id": "z",
"type": "other",
"quantity": 1,
"unitPrice": "q"
}, # what's that price?
{
"id": "rr",
"type": "product",
"quantity": 1,
"product": {
"id": not_visible_product.id
}
} # not visible
]
state = {
"customer": {
"id": contact.id if contact else None,
"billingAddress":
encode_address(contact.default_billing_address) if contact else {},
"shippingAddress": encode_address(contact.default_shipping_address)
if contact else {},
},
"lines": lines,
"methods": {
"shippingMethod": {
"id": get_default_shipping_method().id
},
"paymentMethod": {
"id": get_default_payment_method().id
},
},
"shop": {
"selected": {
"id": shop.id,
"name": shop.name,
"currency": shop.currency,
"priceIncludeTaxes": shop.prices_include_tax
}
}
}
return state
def test_order_create_without_default_address(admin_user):
create_default_order_statuses()
shop = get_default_shop()
sm = get_default_shipping_method()
pm = get_default_payment_method()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
contact.default_billing_address = None
contact.default_shipping_address = None
contact.save()
product = create_product(sku=printable_gibberish(),
supplier=get_default_supplier(),
shop=shop)
assert not Order.objects.count()
client = _get_client(admin_user)
lines = [
{
"type": "product",
"product": product.id,
"quantity": "1",
"base_unit_price_value": "5.00"
},
{
"type": "product",
"product": product.id,
"quantity": "2",
"base_unit_price_value": "1.00",
"discount_amount_value": "0.50"
},
{
"type": "other",
"sku": "hello",
"text": "A greeting",
"quantity": 1,
"base_unit_price_value": "3.5"
},
{
"type": "text",
"text": "This was an order!",
"quantity": 0
},
]
response = client.post("/api/wshop/order/",
content_type="application/json",
data=json.dumps({
"shop": shop.pk,
"shipping_method": sm.pk,
"payment_method": pm.pk,
"customer": contact.pk,
"lines": lines
}))
assert response.status_code == 201
assert Order.objects.count() == 1
order = Order.objects.first()
assert order.shop == shop
assert order.shipping_method == sm
assert order.payment_method == pm
assert order.customer == contact
assert order.creator == admin_user
assert order.billing_address is None
assert order.shipping_address is None
assert order.payment_status == PaymentStatus.NOT_PAID
assert order.shipping_status == ShippingStatus.NOT_SHIPPED
assert order.status == OrderStatus.objects.get_default_initial()
assert order.taxful_total_price_value == decimal.Decimal(10)
assert order.lines.count(
) == 6 # shipping line, payment line, 2 product lines, 2 other lines
for idx, line in enumerate(order.lines.all()[:4]):
assert line.quantity == decimal.Decimal(lines[idx].get("quantity"))
assert line.base_unit_price_value == decimal.Decimal(lines[idx].get(
"base_unit_price_value", 0))
assert line.discount_amount_value == decimal.Decimal(lines[idx].get(
"discount_amount_value", 0))
def login_and_finish_up_the_checkout(browser, live_server, test_username,
test_email, test_password):
browser.fill("login-username", test_email)
browser.fill("login-password", test_password)
click_element(browser, "button[name='login']")
wait_until_condition(browser,
lambda x: x.is_text_present("Addresses"),
timeout=100)
# Reload here just in case since there might have been reload with JS
# which might cause issues with tests since the elements is in cache
browser.reload()
# This should be first order upcoming
assert Order.objects.count() == 0
# Fnish the checkout
customer_name = "Test Tester"
customer_street = "Test Street"
customer_city = "Test City"
customer_region = "CA"
customer_country = "US"
# Fill all necessary information
browser.fill("billing-name", customer_name)
browser.fill("billing-street", customer_street)
browser.fill("billing-city", customer_city)
wait_until_appeared(browser, "#id_billing-region")
browser.select("billing-country", customer_country)
wait_until_disappeared(browser, "#id_billing-region")
wait_until_appeared(browser, "select[name='billing-region_code']")
browser.select("billing-region_code", customer_region)
click_element(browser, "#addresses button[type='submit']")
wait_until_condition(
browser, lambda x: x.is_text_present("This field is required."))
browser.fill("shipping-name", customer_name)
browser.fill("shipping-street", customer_street)
browser.fill("shipping-city", customer_city)
wait_until_appeared(browser, "#id_shipping-region")
browser.select("shipping-country", customer_country)
wait_until_disappeared(browser, "#id_shipping-region")
wait_until_appeared(browser, "select[name='shipping-region_code']")
click_element(browser, "#addresses button[type='submit']")
wait_until_condition(browser,
lambda x: x.is_text_present("Shipping & Payment"))
pm = get_default_payment_method()
sm = get_default_shipping_method()
wait_until_condition(browser, lambda x: x.is_text_present(sm.name)
) # shipping method name is present
wait_until_condition(
browser,
lambda x: x.is_text_present(pm.name)) # payment method name is present
click_element(browser, ".btn.btn-primary.btn-lg.pull-right"
) # click "continue" on methods page
wait_until_condition(browser, lambda x: x.is_text_present("Confirmation")
) # we are indeed in confirmation page
product = Product.objects.first()
# See that all expected texts are present
wait_until_condition(browser, lambda x: x.is_text_present(product.name))
wait_until_condition(browser, lambda x: x.is_text_present(sm.name))
wait_until_condition(browser, lambda x: x.is_text_present(pm.name))
wait_until_condition(browser, lambda x: x.is_text_present("Delivery"))
wait_until_condition(browser, lambda x: x.is_text_present("Billing"))
# check that user information is available
wait_until_condition(browser, lambda x: x.is_text_present(customer_name))
wait_until_condition(browser, lambda x: x.is_text_present(customer_street))
wait_until_condition(browser, lambda x: x.is_text_present(customer_city))
wait_until_condition(browser, lambda x: x.is_text_present("United States"))
browser.execute_script(
'document.getElementById("id_accept_terms").checked=true'
) # click accept terms
click_element(browser, ".btn.btn-primary.btn-lg") # click "place order"
wait_until_condition(browser, lambda x: x.is_text_present(
"Thank you for your order!")) # order succeeded
# Let's make sure the order now has a customer
assert Order.objects.count() == 1
order = Order.objects.first()
assert order.customer == PersonContact.objects.filter(
user__username=test_username).first()
assert order.customer.name == customer_name
assert order.customer.default_shipping_address is not None
assert order.customer.default_billing_address is not None
assert order.customer.user.username == test_username
def test_browser_checkout_horizontal(browser, live_server, settings):
# initialize
product_name = "Test Product"
get_default_shop()
pm = get_default_payment_method()
sm = get_default_shipping_method()
product = create_orderable_product(product_name, "test-123", price=100)
OrderStatus.objects.create(identifier="initial",
role=OrderStatusRole.INITIAL,
name="initial",
default=True)
# initialize test and go to front page
browser = initialize_front_browser_test(browser, live_server)
# check that front page actually loaded
wait_until_condition(browser,
lambda x: x.is_text_present("Welcome to Default!"))
wait_until_condition(browser,
lambda x: x.is_text_present("Newest Products"))
wait_until_condition(browser, lambda x: x.is_text_present(product_name))
click_element(browser,
"#product-%s" % product.pk) # open product from product list
click_element(browser, "#add-to-cart-button-%s" %
product.pk) # add product to basket
wait_until_appeared(browser, ".cover-wrap")
wait_until_disappeared(browser, ".cover-wrap")
click_element(
browser,
"#navigation-basket-partial") # open upper basket navigation menu
click_element(browser,
"a[href='/basket/']") # click the link to basket in dropdown
wait_until_condition(
browser,
lambda x: x.is_text_present("Shopping cart")) # we are in basket page
wait_until_condition(
browser,
lambda x: x.is_text_present(product_name)) # product is in basket
click_element(browser,
"a[href='/checkout/']") # click link that leads to checkout
customer_name = "Test Tester"
customer_street = "Test Street"
customer_city = "Test City"
customer_region = "CA"
customer_country = "US"
# Fill all necessary information
browser.fill("billing-name", customer_name)
browser.fill("billing-street", customer_street)
browser.fill("billing-city", customer_city)
browser.select("billing-country", customer_country)
wait_until_appeared(browser, "select[name='billing-region_code']")
browser.select("billing-region_code", customer_region)
click_element(browser, "#addresses button[type='submit']")
wait_until_condition(
browser, lambda x: x.is_text_present(
"There were errors on submitted form fields. Please check them and try again."
))
# Fill the errors
browser.fill("shipping-name", customer_name)
browser.fill("shipping-street", customer_street)
browser.fill("shipping-city", customer_city)
browser.select("shipping-country", customer_country)
click_element(browser, "#addresses button[type='submit']")
wait_until_condition(
browser, lambda x: x.is_text_present("Checkout: Shipping & Payment"))
wait_until_condition(browser, lambda x: x.is_text_present(sm.name)
) # shipping method name is present
wait_until_condition(
browser,
lambda x: x.is_text_present(pm.name)) # payment method name is present
click_element(browser, ".btn.btn-primary.btn-lg.pull-right"
) # click "continue" on methods page
wait_until_condition(browser, lambda x: x.is_text_present(
"Checkout: Confirmation")) # we are indeed in confirmation page
# See that all expected texts are present
wait_until_condition(browser, lambda x: x.is_text_present(product_name))
wait_until_condition(browser, lambda x: x.is_text_present(sm.name))
wait_until_condition(browser, lambda x: x.is_text_present(pm.name))
wait_until_condition(browser, lambda x: x.is_text_present("Delivery"))
wait_until_condition(browser, lambda x: x.is_text_present("Billing"))
# check that user information is available
wait_until_condition(browser, lambda x: x.is_text_present(customer_name))
wait_until_condition(browser, lambda x: x.is_text_present(customer_street))
wait_until_condition(browser, lambda x: x.is_text_present(customer_city))
wait_until_condition(browser, lambda x: x.is_text_present("United States"))
browser.execute_script(
'document.getElementById("id_accept_terms").checked=true'
) # click accept terms
click_element(browser, ".btn.btn-primary.btn-lg") # click "place order"
wait_until_condition(browser, lambda x: x.is_text_present(
"Thank you for your order!")) # order succeeded
def test_create_order(admin_user, currency):
create_default_order_statuses()
shop = get_default_shop()
shop.currency = currency
tax = get_default_tax()
Currency.objects.get_or_create(code=currency, decimal_places=2)
shop.save()
sm = get_default_shipping_method()
pm = get_default_payment_method()
contact = create_random_person(locale="en_US", minimum_name_comp_len=5)
default_group = get_default_customer_group()
default_group.members.add(contact)
account_manager = create_random_person(locale="en_US",
minimum_name_comp_len=5)
contact.account_manager = account_manager
contact.save()
product = create_product(sku=printable_gibberish(),
supplier=get_default_supplier(),
shop=shop)
assert not Order.objects.count()
client = _get_client(admin_user)
lines = [
{
"type": "product",
"product": product.id,
"quantity": "1",
"base_unit_price_value": "5.00"
},
{
"type": "product",
"product": product.id,
"quantity": "2",
"base_unit_price_value": "1.00",
"discount_amount_value": "0.50"
},
{
"type": "other",
"sku": "hello",
"text": "A greeting",
"quantity": 1,
"base_unit_price_value": "3.5"
},
{
"type": "text",
"text": "This was an order!",
"quantity": 0
},
]
response = client.post("/api/wshop/order/",
content_type="application/json",
data=json.dumps({
"shop": shop.pk,
"shipping_method": sm.pk,
"payment_method": pm.pk,
"customer": contact.pk,
"lines": lines
}))
assert response.status_code == 201
assert Order.objects.count() == 1
order = Order.objects.first()
assert order.shop == shop
assert order.shipping_method == sm
assert order.payment_method == pm
assert order.customer == contact
assert order.creator == admin_user
assert order.billing_address == contact.default_billing_address.to_immutable(
)
assert order.shipping_address == contact.default_shipping_address.to_immutable(
)
assert order.payment_status == PaymentStatus.NOT_PAID
assert order.shipping_status == ShippingStatus.NOT_SHIPPED
assert order.status == OrderStatus.objects.get_default_initial()
assert order.taxful_total_price_value == decimal.Decimal(10)
assert order.lines.count(
) == 6 # shipping line, payment line, 2 product lines, 2 other lines
assert order.currency == currency
for idx, line in enumerate(order.lines.all()[:4]):
assert line.quantity == decimal.Decimal(lines[idx].get("quantity"))
assert line.base_unit_price_value == decimal.Decimal(lines[idx].get(
"base_unit_price_value", 0))
assert line.discount_amount_value == decimal.Decimal(lines[idx].get(
"discount_amount_value", 0))
# Test tax summary
response_data = json.loads(response.content.decode("utf-8"))
# Tax summary should not be present here
assert "summary" not in response_data
response = client.get('/api/wshop/order/{}/taxes/'.format(order.pk))
assert response.status_code == status.HTTP_200_OK
response_data = json.loads(response.content.decode("utf-8"))
assert "lines" in response_data
assert "summary" in response_data
line_summary = response_data["lines"]
summary = response_data["summary"]
first_tax_summary = summary[0]
assert int(first_tax_summary["tax_id"]) == tax.id
assert first_tax_summary["tax_rate"] == tax.rate
first_line_summary = line_summary[0]
assert "tax" in first_line_summary
response = client.get("/api/wshop/order/%s/" % order.id)
assert response.status_code == status.HTTP_200_OK
order_data = json.loads(response.content.decode("utf-8"))
assert order_data.get("id") == order.id
assert "available_shipping_methods" in order_data
assert "available_payment_methods" in order_data
assert order_data["available_payment_methods"][0]["id"] == pm.id
assert order_data["available_shipping_methods"][0]["id"] == sm.id
assert order.account_manager == account_manager
assert order.customer_groups.count() == contact.groups.count()
for group in order.customer_groups.all():
assert contact.groups.filter(id=group.id).exists()
assert order.tax_group is not None
assert order.tax_group == contact.tax_group
