def test_order_weight_add_more_variant(order_with_lines):
variant = order_with_lines.lines.first().variant
add_variant_to_order(order_with_lines, variant, 2)
order_with_lines.refresh_from_db()
assert order_with_lines.weight == _calculate_order_weight_from_lines(
order_with_lines
)
def test_send_confirmation_emails_without_addresses(mocked_templated_email,
order, template,
send_email, site_settings,
digital_content):
assert not order.lines.count()
add_variant_to_order(order, digital_content.product_variant, quantity=1)
order.shipping_address = None
order.shipping_method = None
order.billing_address = None
order.save(update_fields=[
"shipping_address", "shipping_method", "billing_address"
])
send_email(order.pk)
email_data = emails.collect_data_for_email(order.pk, template)
recipients = [order.get_customer_email()]
expected_call_kwargs = {
"context": email_data["context"],
"from_email": site_settings.default_from_email,
"template_name": template,
}
mocked_templated_email.assert_called_once_with(recipient_list=recipients,
**expected_call_kwargs)
# Render the email to ensure there is no error
email_connection = get_connection()
email_connection.get_email_message(to=recipients, **expected_call_kwargs)
def test_order_weight_add_more_variant(order_with_lines):
variant = order_with_lines.lines.first().variant
add_variant_to_order(order_with_lines, variant, 2)
order_with_lines.refresh_from_db()
assert order_with_lines.weight == _calculate_order_weight_from_lines(
order_with_lines
)
def test_send_confirmation_emails_without_addresses(
mocked_templated_email, order, template, send_email, settings, digital_content
):
assert not order.lines.count()
add_variant_to_order(order, digital_content.product_variant, quantity=1)
order.shipping_address = None
order.shipping_method = None
order.billing_address = None
order.save(update_fields=["shipping_address", "shipping_method", "billing_address"])
send_email(order.pk)
email_data = emails.collect_data_for_email(order.pk, template)
recipients = [order.get_user_current_email()]
expected_call_kwargs = {
"context": email_data["context"],
"from_email": settings.ORDER_FROM_EMAIL,
"template_name": template,
}
mocked_templated_email.assert_called_once_with(
recipient_list=recipients, **expected_call_kwargs
)
# Render the email to ensure there is no error
email_connection = get_connection()
email_connection.get_email_message(to=recipients, **expected_call_kwargs)
def test_send_confirmation_emails_without_addresses(mocked_templated_email,
order, template,
send_email, settings,
digital_content):
assert not order.lines.count()
add_variant_to_order(order, digital_content.product_variant, quantity=1)
order.shipping_address = None
order.shipping_method = None
order.billing_address = None
order.save(update_fields=[
'shipping_address', 'shipping_method', 'billing_address'
])
send_email(order.pk)
email_data = emails.collect_data_for_email(order.pk, template)
recipients = [order.get_user_current_email()]
expected_call_kwargs = {
'context': email_data['context'],
'from_email': settings.ORDER_FROM_EMAIL,
'template_name': template
}
mocked_templated_email.assert_called_once_with(recipient_list=recipients,
**expected_call_kwargs)
# Render the email to ensure there is no error
email_connection = get_connection()
email_connection.get_email_message(to=recipients, **expected_call_kwargs)
def test_order_weight_add_new_variant(order_with_lines, product):
variant = product.variants.first()
add_variant_to_order(order_with_lines, variant, 2)
order_with_lines.refresh_from_db()
assert order_with_lines.weight == _calculate_order_weight_from_lines(
order_with_lines
)
def test_order_weight_add_new_variant(order_with_lines, product):
variant = product.variants.first()
add_variant_to_order(order_with_lines, variant, 2)
order_with_lines.refresh_from_db()
assert order_with_lines.weight == _calculate_order_weight_from_lines(
order_with_lines
)
def test_add_variant_to_order_allocates_stock_for_existing_variant(order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
stock_before = variant.quantity_allocated
add_variant_to_order(order_with_lines, variant, 1)
variant.refresh_from_db()
assert variant.quantity_allocated == stock_before + 1
def test_add_variant_to_order_allocates_stock_for_new_variant(
order_with_lines, product):
variant = product.variants.get()
stock_before = variant.quantity_allocated
add_variant_to_order(order_with_lines, variant, 1)
variant.refresh_from_db()
assert variant.quantity_allocated == stock_before + 1
def test_add_variant_to_order_allocates_stock_for_existing_variant(order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
stock_before = variant.quantity_allocated
add_variant_to_order(order_with_lines, variant, 1)
variant.refresh_from_db()
assert variant.quantity_allocated == stock_before + 1
def test_add_variant_to_order_allocates_stock_for_new_variant(
order_with_lines_and_stock, product):
order = order_with_lines_and_stock
variant = product.variants.get()
stock_before = variant.quantity_allocated
add_variant_to_order(order, variant, 1)
variant.refresh_from_db()
assert variant.quantity_allocated == stock_before + 1
def test_add_variant_to_order_allocates_stock_for_new_variant(
order_with_lines, product_in_stock):
order = order_with_lines
variant = product_in_stock.variants.get()
stock = variant.select_stockrecord()
stock_before = stock.quantity_allocated
add_variant_to_order(order, variant, 1)
stock.refresh_from_db()
assert stock.quantity_allocated == stock_before + 1
def test_add_variant_to_order_allocates_stock_for_existing_variant(
order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
stock = Stock.objects.get(product_variant=variant)
stock_before = stock.quantity_allocated
add_variant_to_order(order_with_lines, variant, 1)
stock.refresh_from_db()
assert stock.quantity_allocated == stock_before + 1
def test_add_variant_to_order_allocates_stock_for_new_variant(
order_with_lines, product_in_stock):
order = order_with_lines
variant = product_in_stock.variants.get()
stock = variant.select_stockrecord()
stock_before = stock.quantity_allocated
add_variant_to_order(order, variant, 1)
stock.refresh_from_db()
assert stock.quantity_allocated == stock_before + 1
def test_add_variant_to_order_edits_line_for_existing_variant(order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
lines_before = order_with_lines.lines.count()
line_quantity_before = existing_line.quantity
add_variant_to_order(order_with_lines, variant, 1)
existing_line.refresh_from_db()
assert order_with_lines.lines.count() == lines_before
assert existing_line.product_sku == variant.sku
assert existing_line.quantity == line_quantity_before + 1
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product_in_stock):
order = order_with_lines
variant = product_in_stock.variants.get()
lines_before = order.lines.count()
add_variant_to_order(order, variant, 1)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
def test_add_variant_to_order_allocates_stock_for_existing_variant(
order_with_lines_and_stock):
order = order_with_lines_and_stock
existing_line = order.lines.first()
variant = existing_line.product.variants.get()
stock = existing_line.stock
stock_before = stock.quantity_allocated
add_variant_to_order(order, variant, 1)
stock.refresh_from_db()
assert stock.quantity_allocated == stock_before + 1
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product):
order = order_with_lines
variant = product.variants.get()
lines_before = order.lines.count()
add_variant_to_order(order, variant, 1)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
def test_add_variant_to_order_edits_line_for_existing_variant(order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
lines_before = order_with_lines.lines.count()
line_quantity_before = existing_line.quantity
add_variant_to_order(order_with_lines, variant, 1)
existing_line.refresh_from_db()
assert order_with_lines.lines.count() == lines_before
assert existing_line.product_sku == variant.sku
assert existing_line.quantity == line_quantity_before + 1
def test_add_variant_to_order_allocates_stock_for_existing_variant(
order_with_lines_and_stock):
order = order_with_lines_and_stock
existing_line = order.lines.first()
variant = existing_line.product.variants.get()
stock = existing_line.stock
stock_before = stock.quantity_allocated
add_variant_to_order(order, variant, 1)
stock.refresh_from_db()
assert stock.quantity_allocated == stock_before + 1
def test_get_order_weight_non_existing_product(order_with_lines, product):
# Removing product should not affect order's weight
order = order_with_lines
variant = product.variants.first()
add_variant_to_order(order, variant, 1)
old_weight = order.get_total_weight()
product.delete()
order.refresh_from_db()
new_weight = order.get_total_weight()
assert old_weight == new_weight
def test_get_order_weight_non_existing_product(order_with_lines, product):
# Removing product should not affect order's weight
order = order_with_lines
variant = product.variants.first()
add_variant_to_order(order, variant, 1)
old_weight = order.get_total_weight()
product.delete()
order.refresh_from_db()
new_weight = order.get_total_weight()
assert old_weight == new_weight
def test_add_variant_to_order_allow_overselling(order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
stock_before = variant.quantity_allocated
quantity = variant.quantity + 1
with pytest.raises(InsufficientStock):
add_variant_to_order(
order_with_lines, variant, quantity, allow_overselling=False)
add_variant_to_order(
order_with_lines, variant, quantity, allow_overselling=True)
variant.refresh_from_db()
assert variant.quantity_allocated == stock_before + quantity
def test_add_variant_to_order_allow_overselling(order_with_lines):
existing_line = order_with_lines.lines.first()
variant = existing_line.variant
stock_before = variant.quantity_allocated
quantity = variant.quantity + 1
with pytest.raises(InsufficientStock):
add_variant_to_order(
order_with_lines, variant, quantity, allow_overselling=False
)
add_variant_to_order(order_with_lines, variant, quantity, allow_overselling=True)
variant.refresh_from_db()
assert variant.quantity_allocated == stock_before + quantity
def test_add_variant_to_order_allocates_stock_for_new_variant(
order_with_lines, product, track_inventory):
variant = product.variants.get()
variant.track_inventory = track_inventory
variant.save()
stock_before = variant.quantity_allocated
add_variant_to_order(order_with_lines, variant, 1)
variant.refresh_from_db()
if track_inventory:
assert variant.quantity_allocated == stock_before + 1
else:
assert variant.quantity_allocated == stock_before
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product, taxes):
order = order_with_lines
variant = product.variants.get()
lines_before = order.lines.count()
add_variant_to_order(order, variant, 1, taxes=taxes)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
assert line.unit_price == TaxedMoney(
net=Money('8.13', 'USD'), gross=Money(10, 'USD'))
assert line.tax_rate == taxes[product.tax_rate]['value']
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product, taxes):
order = order_with_lines
variant = product.variants.get()
lines_before = order.lines.count()
add_variant_to_order(order, variant, 1, taxes=taxes)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
assert line.unit_price == TaxedMoney(net=Money('8.13', 'USD'),
gross=Money(10, 'USD'))
assert line.tax_rate == taxes[product.tax_rate]['value']
def test_add_variant_to_order_allocates_stock_for_new_variant(
order_with_lines, product, track_inventory):
variant = product.variants.get()
variant.track_inventory = track_inventory
variant.save()
stock_before = variant.quantity_allocated
add_variant_to_order(order_with_lines, variant, 1)
variant.refresh_from_db()
if track_inventory:
assert variant.quantity_allocated == stock_before + 1
else:
assert variant.quantity_allocated == stock_before
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product, product_translation_fr, settings):
order = order_with_lines
variant = product.variants.get()
lines_before = order.lines.count()
settings.LANGUAGE_CODE = "fr"
add_variant_to_order(order, variant, 1)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
assert line.unit_price == TaxedMoney(net=Money(10, "USD"),
gross=Money(10, "USD"))
assert line.translated_product_name == variant.display_product(
translated=True)
def save(cls, info, instance, cleaned_input):
shipping_address = cleaned_input.get('shipping_address')
if shipping_address:
shipping_address.save()
instance.shipping_address = shipping_address
billing_address = cleaned_input.get('billing_address')
if billing_address:
billing_address.save()
instance.billing_address = billing_address
super().save(info, instance, cleaned_input)
instance.save(update_fields=['billing_address', 'shipping_address'])
variants = cleaned_input.get('variants')
quantities = cleaned_input.get('quantities')
if variants and quantities:
for variant, quantity in zip(variants, quantities):
add_variant_to_order(instance, variant, quantity)
recalculate_order(instance)
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product, taxes, product_translation_fr, settings):
order = order_with_lines
variant = product.variants.get()
lines_before = order.lines.count()
settings.LANGUAGE_CODE = 'fr'
add_variant_to_order(order, variant, 1, taxes=taxes)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
assert line.unit_price == TaxedMoney(net=Money('8.13', 'USD'),
gross=Money(10, 'USD'))
assert line.tax_rate == taxes[product.tax_rate]['value']
assert line.translated_product_name == variant.display_product(
translated=True)
def test_add_variant_to_order_adds_line_for_new_variant(
order_with_lines, product, taxes, product_translation_fr, settings):
order = order_with_lines
variant = product.variants.get()
lines_before = order.lines.count()
settings.LANGUAGE_CODE = 'fr'
add_variant_to_order(order, variant, 1, taxes=taxes)
line = order.lines.last()
assert order.lines.count() == lines_before + 1
assert line.product_sku == variant.sku
assert line.quantity == 1
assert line.unit_price == TaxedMoney(
net=Money('8.13', 'USD'), gross=Money(10, 'USD'))
assert line.tax_rate == taxes[product.tax_rate]['value']
assert line.translated_product_name == variant.display_product(
translated=True)
def save(cls, info, instance, cleaned_input):
shipping_address = cleaned_input.get('shipping_address')
if shipping_address:
shipping_address.save()
instance.shipping_address = shipping_address
billing_address = cleaned_input.get('billing_address')
if billing_address:
billing_address.save()
instance.billing_address = billing_address
super().save(info, instance, cleaned_input)
instance.save(update_fields=['billing_address', 'shipping_address'])
variants = cleaned_input.get('variants')
quantities = cleaned_input.get('quantities')
if variants and quantities:
for variant, quantity in zip(variants, quantities):
add_variant_to_order(instance, variant, quantity)
recalculate_order(instance)
def test_dashboard_change_quantity_form(request_cart_with_item, order):
cart = request_cart_with_item
for line in cart.lines.all():
add_variant_to_order(order, line.variant, line.quantity)
order_line = order.lines.get()
quantity_before = order_line.variant.quantity_allocated
# Check max quantity validation
form = ChangeQuantityForm({'quantity': 9999}, instance=order_line)
assert not form.is_valid()
assert form.errors['quantity'] == [
'Ensure this value is less than or equal to 50.']
# Check minimum quantity validation
form = ChangeQuantityForm({'quantity': 0}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().variant.quantity_allocated == quantity_before
assert 'quantity' in form.errors
# Check available quantity validation
form = ChangeQuantityForm({'quantity': 20}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().variant.quantity_allocated == quantity_before
assert 'quantity' in form.errors
# Save same quantity
form = ChangeQuantityForm(
{'quantity': 1}, instance=order_line)
assert form.is_valid()
form.save()
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before
# Increase quantity
form = ChangeQuantityForm(
{'quantity': 2}, instance=order_line)
assert form.is_valid()
form.save()
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before + 1
# Decrease quantity
form = ChangeQuantityForm({'quantity': 1}, instance=order_line)
assert form.is_valid()
form.save()
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before
def test_dashboard_change_quantity_form(request_cart_with_item, order):
for line in request_cart_with_item:
add_variant_to_order(order, line.variant, line.quantity)
order_line = order.lines.get()
quantity_before = order_line.variant.quantity_allocated
# Check max quantity validation
form = ChangeQuantityForm({'quantity': 9999}, instance=order_line)
assert not form.is_valid()
assert form.errors['quantity'] == [
'Ensure this value is less than or equal to 50.']
# Check minimum quantity validation
form = ChangeQuantityForm({'quantity': 0}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().variant.quantity_allocated == quantity_before
assert 'quantity' in form.errors
# Check available quantity validation
form = ChangeQuantityForm({'quantity': 20}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().variant.quantity_allocated == quantity_before
assert 'quantity' in form.errors
# Save same quantity
form = ChangeQuantityForm(
{'quantity': 1}, instance=order_line)
assert form.is_valid()
form.save()
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before
# Increase quantity
form = ChangeQuantityForm(
{'quantity': 2}, instance=order_line)
assert form.is_valid()
form.save()
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before + 1
# Decrease quantity
form = ChangeQuantityForm({'quantity': 1}, instance=order_line)
assert form.is_valid()
form.save()
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before
def test_dashboard_change_quantity_form(request_cart_with_item, order):
cart = request_cart_with_item
for line in cart.lines.all():
add_variant_to_order(order, line.variant, line.quantity)
order_line = order.lines.get()
# Check max quantity validation
form = ChangeQuantityForm({'quantity': 9999}, instance=order_line)
assert not form.is_valid()
assert form.errors['quantity'] == [
'Ensure this value is less than or equal to 50.'
]
# Check minimum quantity validation
form = ChangeQuantityForm({'quantity': 0}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().stock.quantity_allocated == 1
# Check available quantity validation
form = ChangeQuantityForm({'quantity': 20}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().stock.quantity_allocated == 1
assert form.errors['quantity'] == ['Only 5 remaining in stock.']
# Save same quantity
form = ChangeQuantityForm({'quantity': 1}, instance=order_line)
assert form.is_valid()
form.save()
order_line.stock.refresh_from_db()
assert order.lines.get().stock.quantity_allocated == 1
# Increase quantity
form = ChangeQuantityForm({'quantity': 2}, instance=order_line)
assert form.is_valid()
form.save()
order_line.stock.refresh_from_db()
assert order.lines.get().stock.quantity_allocated == 2
# Decrease quantity
form = ChangeQuantityForm({'quantity': 1}, instance=order_line)
assert form.is_valid()
form.save()
assert order.lines.get().stock.quantity_allocated == 1
def test_dashboard_change_quantity_form(request_checkout_with_item, order):
for line in request_checkout_with_item:
add_variant_to_order(order, line.variant, line.quantity)
order_line = order.lines.get()
quantity_before = order_line.variant.quantity_allocated
# Check max quantity validation
form = ChangeQuantityForm({"quantity": 9999}, instance=order_line)
assert not form.is_valid()
assert form.errors["quantity"] == ["Ensure this value is less than or equal to 50."]
# Check minimum quantity validation
form = ChangeQuantityForm({"quantity": 0}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().variant.quantity_allocated == quantity_before
assert "quantity" in form.errors
# Check available quantity validation
form = ChangeQuantityForm({"quantity": 20}, instance=order_line)
assert not form.is_valid()
assert order.lines.get().variant.quantity_allocated == quantity_before
assert "quantity" in form.errors
# Save same quantity
form = ChangeQuantityForm({"quantity": 1}, instance=order_line)
assert form.is_valid()
form.save(None)
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before
# Increase quantity
form = ChangeQuantityForm({"quantity": 2}, instance=order_line)
assert form.is_valid()
form.save(None)
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before + 1
# Decrease quantity
form = ChangeQuantityForm({"quantity": 1}, instance=order_line)
assert form.is_valid()
form.save(None)
order_line.variant.refresh_from_db()
assert order_line.variant.quantity_allocated == quantity_before
