03c7633169
There are a number of attempts to use Deci in ints, which won't work in 2.7 or 3.x, we fix that. Description doesn't exist in symposion. So that fails our tests pretty hard. Switch that to Private Abstract. It's clear these tests have not been run in a very long time. So both failures and especially passes need to be taken with salt.
376 lines
14 KiB
Python
376 lines
14 KiB
Python
import datetime
|
|
import pytz
|
|
|
|
from decimal import Decimal
|
|
from django.core.exceptions import ValidationError
|
|
|
|
from registrasion.models import commerce
|
|
from registrasion.models import conditions
|
|
from registrasion.models import inventory
|
|
from registrasion.tests.controller_helpers import TestingCartController
|
|
from registrasion.tests.controller_helpers import TestingInvoiceController
|
|
from registrasion.tests.test_helpers import TestHelperMixin
|
|
|
|
from registrasion.tests.test_cart import RegistrationCartTestCase
|
|
|
|
UTC = pytz.timezone('UTC')
|
|
|
|
|
|
class InvoiceTestCase(TestHelperMixin, RegistrationCartTestCase):
|
|
|
|
def test_create_invoice(self):
|
|
current_cart = TestingCartController.for_user(self.USER_1)
|
|
|
|
# Should be able to create an invoice after the product is added
|
|
current_cart.add_to_cart(self.PROD_1, 1)
|
|
invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)
|
|
# That invoice should have a single line item
|
|
line_items = commerce.LineItem.objects.filter(
|
|
invoice=invoice_1.invoice,
|
|
)
|
|
self.assertEqual(1, len(line_items))
|
|
# That invoice should have a value equal to cost of PROD_1
|
|
self.assertEqual(self.PROD_1.price, invoice_1.invoice.value)
|
|
|
|
# Adding item to cart should produce a new invoice
|
|
current_cart.add_to_cart(self.PROD_2, 1)
|
|
invoice_2 = TestingInvoiceController.for_cart(current_cart.cart)
|
|
self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)
|
|
|
|
# The old invoice should automatically be voided
|
|
invoice_1_new = commerce.Invoice.objects.get(pk=invoice_1.invoice.id)
|
|
invoice_2_new = commerce.Invoice.objects.get(pk=invoice_2.invoice.id)
|
|
self.assertTrue(invoice_1_new.is_void)
|
|
self.assertFalse(invoice_2_new.is_void)
|
|
|
|
# Invoice should have two line items
|
|
line_items = commerce.LineItem.objects.filter(
|
|
invoice=invoice_2.invoice,
|
|
)
|
|
self.assertEqual(2, len(line_items))
|
|
# Invoice should have a value equal to cost of PROD_1 and PROD_2
|
|
self.assertEqual(
|
|
self.PROD_1.price + self.PROD_2.price,
|
|
invoice_2.invoice.value)
|
|
|
|
def test_invoice_controller_for_id_works(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
|
|
id_ = invoice.invoice.id
|
|
|
|
invoice1 = TestingInvoiceController.for_id(id_)
|
|
invoice2 = TestingInvoiceController.for_id(str(id_))
|
|
|
|
self.assertEqual(invoice.invoice, invoice1.invoice)
|
|
self.assertEqual(invoice.invoice, invoice2.invoice)
|
|
|
|
def test_create_invoice_fails_if_cart_invalid(self):
|
|
self.make_ceiling("Limit ceiling", limit=1)
|
|
self.set_time(datetime.datetime(2015, 1, 1, tzinfo=UTC))
|
|
current_cart = TestingCartController.for_user(self.USER_1)
|
|
current_cart.add_to_cart(self.PROD_1, 1)
|
|
|
|
self.add_timedelta(self.RESERVATION * 2)
|
|
cart_2 = TestingCartController.for_user(self.USER_2)
|
|
cart_2.add_to_cart(self.PROD_1, 1)
|
|
|
|
# Now try to invoice the first user
|
|
with self.assertRaises(ValidationError):
|
|
TestingInvoiceController.for_cart(current_cart.cart)
|
|
|
|
def test_paying_invoice_makes_new_cart(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
|
|
invoice.pay("A payment!", invoice.invoice.value)
|
|
|
|
# This payment is for the correct amount invoice should be paid.
|
|
self.assertTrue(invoice.invoice.is_paid)
|
|
|
|
# Cart should not be active
|
|
self.assertNotEqual(
|
|
commerce.Cart.STATUS_ACTIVE,
|
|
invoice.invoice.cart.status,
|
|
)
|
|
|
|
# Asking for a cart should generate a new one
|
|
new_cart = TestingCartController.for_user(self.USER_1)
|
|
self.assertNotEqual(invoice.invoice.cart, new_cart.cart)
|
|
|
|
def test_total_payments_balance_due(self):
|
|
invoice = self._invoice_containing_prod_1(2)
|
|
# range only takes int, and the following logic fails if not a round
|
|
# number. So fail if we are not a round number so developer may fix
|
|
# this test or the product.
|
|
self.assertTrue((invoice.invoice.value % 1).is_zero())
|
|
for i in range(0, int(invoice.invoice.value)):
|
|
self.assertTrue(
|
|
i + 1, invoice.invoice.total_payments()
|
|
)
|
|
self.assertTrue(
|
|
invoice.invoice.value - i, invoice.invoice.balance_due()
|
|
)
|
|
invoice.pay("Pay 1", 1)
|
|
|
|
def test_invoice_includes_discounts(self):
|
|
voucher = inventory.Voucher.objects.create(
|
|
recipient="Voucher recipient",
|
|
code="VOUCHER",
|
|
limit=1
|
|
)
|
|
discount = conditions.VoucherDiscount.objects.create(
|
|
description="VOUCHER RECIPIENT",
|
|
voucher=voucher,
|
|
)
|
|
conditions.DiscountForProduct.objects.create(
|
|
discount=discount,
|
|
product=self.PROD_1,
|
|
percentage=Decimal(50),
|
|
quantity=1
|
|
)
|
|
|
|
current_cart = TestingCartController.for_user(self.USER_1)
|
|
current_cart.apply_voucher(voucher.code)
|
|
|
|
# Should be able to create an invoice after the product is added
|
|
current_cart.add_to_cart(self.PROD_1, 1)
|
|
invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)
|
|
|
|
# That invoice should have two line items
|
|
line_items = commerce.LineItem.objects.filter(
|
|
invoice=invoice_1.invoice,
|
|
)
|
|
self.assertEqual(2, len(line_items))
|
|
# That invoice should have a value equal to 50% of the cost of PROD_1
|
|
self.assertEqual(
|
|
self.PROD_1.price * Decimal("0.5"),
|
|
invoice_1.invoice.value)
|
|
|
|
def _make_zero_value_invoice(self):
|
|
voucher = inventory.Voucher.objects.create(
|
|
recipient="Voucher recipient",
|
|
code="VOUCHER",
|
|
limit=1
|
|
)
|
|
discount = conditions.VoucherDiscount.objects.create(
|
|
description="VOUCHER RECIPIENT",
|
|
voucher=voucher,
|
|
)
|
|
conditions.DiscountForProduct.objects.create(
|
|
discount=discount,
|
|
product=self.PROD_1,
|
|
percentage=Decimal(100),
|
|
quantity=1
|
|
)
|
|
|
|
current_cart = TestingCartController.for_user(self.USER_1)
|
|
current_cart.apply_voucher(voucher.code)
|
|
|
|
# Should be able to create an invoice after the product is added
|
|
current_cart.add_to_cart(self.PROD_1, 1)
|
|
return TestingInvoiceController.for_cart(current_cart.cart)
|
|
|
|
def test_zero_value_invoice_is_automatically_paid(self):
|
|
invoice_1 = self._make_zero_value_invoice()
|
|
self.assertTrue(invoice_1.invoice.is_paid)
|
|
|
|
def test_refunding_zero_value_invoice_releases_cart(self):
|
|
invoice_1 = self._make_zero_value_invoice()
|
|
cart = invoice_1.invoice.cart
|
|
invoice_1.refund()
|
|
|
|
cart.refresh_from_db()
|
|
self.assertEquals(commerce.Cart.STATUS_RELEASED, cart.status)
|
|
|
|
def test_invoice_voids_self_if_cart_changes(self):
|
|
current_cart = TestingCartController.for_user(self.USER_1)
|
|
|
|
# Should be able to create an invoice after the product is added
|
|
current_cart.add_to_cart(self.PROD_1, 1)
|
|
invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)
|
|
|
|
self.assertFalse(invoice_1.invoice.is_void)
|
|
|
|
# Adding item to cart should produce a new invoice
|
|
current_cart.add_to_cart(self.PROD_2, 1)
|
|
invoice_2 = TestingInvoiceController.for_cart(current_cart.cart)
|
|
self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)
|
|
|
|
# Viewing invoice_1's invoice should show it as void
|
|
invoice_1_new = TestingInvoiceController(invoice_1.invoice)
|
|
self.assertTrue(invoice_1_new.invoice.is_void)
|
|
|
|
# Viewing invoice_2's invoice should *not* show it as void
|
|
invoice_2_new = TestingInvoiceController(invoice_2.invoice)
|
|
self.assertFalse(invoice_2_new.invoice.is_void)
|
|
|
|
def test_invoice_voids_self_if_cart_becomes_invalid(self):
|
|
''' Invoices should be void if cart becomes invalid over time '''
|
|
|
|
self.make_ceiling("Limit ceiling", limit=1)
|
|
self.set_time(datetime.datetime(
|
|
year=2015, month=1, day=1, hour=0, minute=0, tzinfo=UTC,
|
|
))
|
|
|
|
cart1 = TestingCartController.for_user(self.USER_1)
|
|
cart2 = TestingCartController.for_user(self.USER_2)
|
|
|
|
# Create a valid invoice for USER_1
|
|
cart1.add_to_cart(self.PROD_1, 1)
|
|
inv1 = TestingInvoiceController.for_cart(cart1.cart)
|
|
|
|
# Expire the reservations, and have USER_2 take up PROD_1's ceiling
|
|
# generate an invoice
|
|
self.add_timedelta(self.RESERVATION * 2)
|
|
cart2.add_to_cart(self.PROD_2, 1)
|
|
TestingInvoiceController.for_cart(cart2.cart)
|
|
|
|
# Re-get inv1's invoice; it should void itself on loading.
|
|
inv1 = TestingInvoiceController(inv1.invoice)
|
|
self.assertTrue(inv1.invoice.is_void)
|
|
|
|
def test_voiding_invoice_creates_new_invoice(self):
|
|
invoice_1 = self._invoice_containing_prod_1(1)
|
|
|
|
self.assertFalse(invoice_1.invoice.is_void)
|
|
invoice_1.void()
|
|
|
|
invoice_2 = TestingInvoiceController.for_cart(invoice_1.invoice.cart)
|
|
self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)
|
|
|
|
def test_cannot_pay_void_invoice(self):
|
|
invoice_1 = self._invoice_containing_prod_1(1)
|
|
|
|
invoice_1.void()
|
|
|
|
with self.assertRaises(ValidationError):
|
|
invoice_1.validate_allowed_to_pay()
|
|
|
|
def test_cannot_void_paid_invoice(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
|
|
invoice.pay("Reference", invoice.invoice.value)
|
|
|
|
with self.assertRaises(ValidationError):
|
|
invoice.void()
|
|
|
|
def test_cannot_void_partially_paid_invoice(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
|
|
invoice.pay("Reference", invoice.invoice.value - 1)
|
|
self.assertTrue(invoice.invoice.is_unpaid)
|
|
|
|
with self.assertRaises(ValidationError):
|
|
invoice.void()
|
|
|
|
def test_cannot_generate_blank_invoice(self):
|
|
current_cart = TestingCartController.for_user(self.USER_1)
|
|
with self.assertRaises(ValidationError):
|
|
TestingInvoiceController.for_cart(current_cart.cart)
|
|
|
|
def test_cannot_pay_implicitly_void_invoice(self):
|
|
cart = TestingCartController.for_user(self.USER_1)
|
|
cart.add_to_cart(self.PROD_1, 1)
|
|
invoice = TestingInvoiceController.for_cart(self.reget(cart.cart))
|
|
|
|
# Implicitly void the invoice
|
|
cart.add_to_cart(self.PROD_1, 1)
|
|
|
|
with self.assertRaises(ValidationError):
|
|
invoice.validate_allowed_to_pay()
|
|
|
|
def test_required_category_constraints_prevent_invoicing(self):
|
|
self.CAT_1.required = True
|
|
self.CAT_1.save()
|
|
|
|
cart = TestingCartController.for_user(self.USER_1)
|
|
cart.add_to_cart(self.PROD_3, 1)
|
|
|
|
# CAT_1 is required, we don't have CAT_1 yet
|
|
with self.assertRaises(ValidationError):
|
|
invoice = TestingInvoiceController.for_cart(cart.cart)
|
|
|
|
# Now that we have CAT_1, we can check out the cart
|
|
cart.add_to_cart(self.PROD_1, 1)
|
|
invoice = TestingInvoiceController.for_cart(cart.cart)
|
|
|
|
# Paying for the invoice should work fine
|
|
invoice.pay("Boop", invoice.invoice.value)
|
|
|
|
# We have an item in the first cart, so should be able to invoice
|
|
# for the second cart, even without CAT_1 in it.
|
|
cart = TestingCartController.for_user(self.USER_1)
|
|
cart.add_to_cart(self.PROD_3, 1)
|
|
|
|
invoice2 = TestingInvoiceController.for_cart(cart.cart)
|
|
|
|
# Void invoice2, and release the first cart
|
|
# now we don't have any CAT_1
|
|
invoice2.void()
|
|
invoice.refund()
|
|
|
|
# Now that we don't have CAT_1, we can't checkout this cart
|
|
with self.assertRaises(ValidationError):
|
|
invoice = TestingInvoiceController.for_cart(cart.cart)
|
|
|
|
def test_can_generate_manual_invoice(self):
|
|
|
|
description_price_pairs = [
|
|
("Item 1", 15),
|
|
("Item 2", 30),
|
|
]
|
|
|
|
due_delta = datetime.timedelta(hours=24)
|
|
|
|
_invoice = TestingInvoiceController.manual_invoice(
|
|
self.USER_1, due_delta, description_price_pairs
|
|
)
|
|
inv = TestingInvoiceController(_invoice)
|
|
|
|
self.assertEquals(
|
|
inv.invoice.value,
|
|
sum(i[1] for i in description_price_pairs)
|
|
)
|
|
|
|
self.assertEquals(
|
|
len(inv.invoice.lineitem_set.all()),
|
|
len(description_price_pairs)
|
|
)
|
|
|
|
inv.pay("Demo payment", inv.invoice.value)
|
|
|
|
def test_sends_email_on_invoice_creation(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
self.assertEquals(1, len(self.emails))
|
|
email = self.emails[0]
|
|
self.assertEquals([self.USER_1.email], email["to"])
|
|
self.assertEquals("invoice_created", email["kind"])
|
|
self.assertEquals(invoice.invoice, email["context"]["invoice"])
|
|
|
|
def test_sends_first_change_email_on_invoice_fully_paid(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
|
|
self.assertEquals(1, len(self.emails))
|
|
invoice.pay("Partial", invoice.invoice.value - 1)
|
|
# Should have an "invoice_created" email and nothing else.
|
|
self.assertEquals(1, len(self.emails))
|
|
invoice.pay("Remainder", 1)
|
|
self.assertEquals(2, len(self.emails))
|
|
|
|
email = self.emails[1]
|
|
self.assertEquals([self.USER_1.email], email["to"])
|
|
self.assertEquals("invoice_updated", email["kind"])
|
|
self.assertEquals(invoice.invoice, email["context"]["invoice"])
|
|
|
|
def test_sends_email_when_invoice_refunded(self):
|
|
invoice = self._invoice_containing_prod_1(1)
|
|
|
|
self.assertEquals(1, len(self.emails))
|
|
invoice.pay("Payment", invoice.invoice.value)
|
|
self.assertEquals(2, len(self.emails))
|
|
invoice.refund()
|
|
self.assertEquals(3, len(self.emails))
|
|
|
|
email = self.emails[2]
|
|
self.assertEquals([self.USER_1.email], email["to"])
|
|
self.assertEquals("invoice_updated", email["kind"])
|
|
self.assertEquals(invoice.invoice, email["context"]["invoice"])
|