diff --git a/registrasion/controllers/invoice.py b/registrasion/controllers/invoice.py index a2adca4e..09eb02da 100644 --- a/registrasion/controllers/invoice.py +++ b/registrasion/controllers/invoice.py @@ -198,10 +198,35 @@ class InvoiceController(ForId, object): commerce.LineItem.objects.bulk_create(line_items) + cls._apply_credit_notes(invoice) cls.email_on_invoice_creation(invoice) return invoice + @classmethod + def _apply_credit_notes(cls, invoice): + ''' Applies the user's credit notes to the given invoice on creation. + ''' + + # We only automatically apply credit notes if this is the *only* + # unpaid invoice for this user. + invoices = commerce.Invoice.objects.filter( + user=invoice.user, + status=commerce.Invoice.STATUS_UNPAID, + ) + if invoices.count() > 1: + return + + notes = commerce.CreditNote.objects.filter(invoice__user=invoice.user) + for note in notes: + try: + CreditNoteController(note).apply_to_invoice(invoice) + except ValidationError: + # ValidationError will get raised once we're overpaying. + break + + invoice.refresh_from_db() + def can_view(self, user=None, access_code=None): ''' Returns true if the accessing user is allowed to view this invoice, or if the given access code matches this invoice's user's access code. diff --git a/registrasion/tests/test_credit_note.py b/registrasion/tests/test_credit_note.py new file mode 100644 index 00000000..3e6d1cd6 --- /dev/null +++ b/registrasion/tests/test_credit_note.py @@ -0,0 +1,430 @@ +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 controller_helpers import TestingCartController +from controller_helpers import TestingCreditNoteController +from controller_helpers import TestingInvoiceController +from test_helpers import TestHelperMixin + +from test_cart import RegistrationCartTestCase + +UTC = pytz.timezone('UTC') + +HOURS = datetime.timedelta(hours=1) + + +class CreditNoteTestCase(TestHelperMixin, RegistrationCartTestCase): + + def test_overpaid_invoice_results_in_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + # Invoice is overpaid by 1 unit + to_pay = invoice.invoice.value + 1 + invoice.pay("Reference", to_pay) + + # The total paid should be equal to the value of the invoice only + self.assertEqual(invoice.invoice.value, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_paid) + + # There should be a credit note generated out of the invoice. + credit_notes = commerce.CreditNote.objects.filter( + invoice=invoice.invoice, + ) + self.assertEqual(1, credit_notes.count()) + self.assertEqual(to_pay - invoice.invoice.value, credit_notes[0].value) + + def test_full_paid_invoice_does_not_generate_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + # Invoice is paid evenly + invoice.pay("Reference", invoice.invoice.value) + + # The total paid should be equal to the value of the invoice only + self.assertEqual(invoice.invoice.value, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_paid) + + # There should be no credit notes + credit_notes = commerce.CreditNote.objects.filter( + invoice=invoice.invoice, + ) + self.assertEqual(0, credit_notes.count()) + + def test_refund_partially_paid_invoice_generates_correct_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + # Invoice is underpaid by 1 unit + to_pay = invoice.invoice.value - 1 + invoice.pay("Reference", to_pay) + invoice.refund() + + # The total paid should be zero + self.assertEqual(0, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_void) + + # There should be a credit note generated out of the invoice. + credit_notes = commerce.CreditNote.objects.filter( + invoice=invoice.invoice, + ) + self.assertEqual(1, credit_notes.count()) + self.assertEqual(to_pay, credit_notes[0].value) + + def test_refund_fully_paid_invoice_generates_correct_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + to_pay = invoice.invoice.value + invoice.pay("Reference", to_pay) + self.assertTrue(invoice.invoice.is_paid) + + invoice.refund() + + # The total paid should be zero + self.assertEqual(0, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_refunded) + + # There should be a credit note generated out of the invoice. + credit_notes = commerce.CreditNote.objects.filter( + invoice=invoice.invoice, + ) + self.assertEqual(1, credit_notes.count()) + self.assertEqual(to_pay, credit_notes[0].value) + + def test_apply_credit_note_pays_invoice(self): + + # Create a manual invoice (stops credit notes from being auto-applied) + self._manual_invoice(1) + + # Begin the test + + invoice = self._invoice_containing_prod_1(1) + + to_pay = invoice.invoice.value + invoice.pay("Reference", to_pay) + self.assertTrue(invoice.invoice.is_paid) + + invoice.refund() + + # There should be one credit note generated out of the invoice. + cn = self._credit_note_for_invoice(invoice.invoice) + + # That credit note should be in the unclaimed pile + self.assertEquals(1, commerce.CreditNote.unclaimed().count()) + + # Create a new (identical) cart with invoice + cart = TestingCartController.for_user(self.USER_1) + cart.add_to_cart(self.PROD_1, 1) + + invoice2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) + + cn.apply_to_invoice(invoice2.invoice) + self.assertTrue(invoice2.invoice.is_paid) + + # That invoice should not show up as unclaimed any more + self.assertEquals(0, commerce.CreditNote.unclaimed().count()) + + def test_apply_credit_note_generates_new_credit_note_if_overpaying(self): + + # Create and refund an invoice, generating a credit note. + invoice = self._invoice_containing_prod_1(2) + + invoice.pay("Reference", invoice.invoice.value) + self.assertTrue(invoice.invoice.is_paid) + + invoice.refund() + + # There should be one credit note generated out of the invoice. + cn = self._credit_note_for_invoice(invoice.invoice) + + self.assertEquals(1, commerce.CreditNote.unclaimed().count()) + + # Create a new invoice for a cart of half value of inv 1 + invoice2 = self._invoice_containing_prod_1(1) + # Credit note is automatically applied by generating the new invoice + self.assertTrue(invoice2.invoice.is_paid) + + # We generated a new credit note, and spent the old one, + # unclaimed should still be 1. + self.assertEquals(1, commerce.CreditNote.unclaimed().count()) + + credit_note2 = commerce.CreditNote.objects.get( + invoice=invoice2.invoice, + ) + + # The new credit note should be the residual of the cost of cart 1 + # minus the cost of cart 2. + self.assertEquals( + invoice.invoice.value - invoice2.invoice.value, + credit_note2.value, + ) + + def test_cannot_apply_credit_note_on_invalid_invoices(self): + + # Disable auto-application of invoices. + self._manual_invoice(1) + + # And now start the actual test. + + invoice = self._invoice_containing_prod_1(1) + + to_pay = invoice.invoice.value + invoice.pay("Reference", to_pay) + self.assertTrue(invoice.invoice.is_paid) + + invoice.refund() + + # There should be one credit note generated out of the invoice. + cn = self._credit_note_for_invoice(invoice.invoice) + + # Create a new cart with invoice, pay it + invoice_2 = self._invoice_containing_prod_1(1) + invoice_2.pay("LOL", invoice_2.invoice.value) + + # Cannot pay paid invoice + with self.assertRaises(ValidationError): + cn.apply_to_invoice(invoice_2.invoice) + + invoice_2.refund() + # Cannot pay refunded invoice + with self.assertRaises(ValidationError): + cn.apply_to_invoice(invoice_2.invoice) + + # Create a new cart with invoice + invoice_2 = self._invoice_containing_prod_1(1) + invoice_2.void() + # Cannot pay void invoice + with self.assertRaises(ValidationError): + cn.apply_to_invoice(invoice_2.invoice) + + def test_cannot_apply_a_refunded_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + to_pay = invoice.invoice.value + invoice.pay("Reference", to_pay) + self.assertTrue(invoice.invoice.is_paid) + + invoice.refund() + + self.assertEquals(1, commerce.CreditNote.unclaimed().count()) + + cn = self._credit_note_for_invoice(invoice.invoice) + + cn.refund() + + # Refunding a credit note should mark it as claimed + self.assertEquals(0, commerce.CreditNote.unclaimed().count()) + + # Create a new cart with invoice + cart = TestingCartController.for_user(self.USER_1) + cart.add_to_cart(self.PROD_1, 1) + + invoice_2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) + + # Cannot pay with this credit note. + with self.assertRaises(ValidationError): + cn.apply_to_invoice(invoice_2.invoice) + + def test_cannot_refund_an_applied_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + to_pay = invoice.invoice.value + invoice.pay("Reference", to_pay) + self.assertTrue(invoice.invoice.is_paid) + + invoice.refund() + + self.assertEquals(1, commerce.CreditNote.unclaimed().count()) + + cn = self._credit_note_for_invoice(invoice.invoice) + + # Create a new cart with invoice + cart = TestingCartController.for_user(self.USER_1) + cart.add_to_cart(self.PROD_1, 1) + + invoice_2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) + with self.assertRaises(ValidationError): + # Creating `invoice_2` will automatically apply `cn`. + cn.apply_to_invoice(invoice_2.invoice) + + self.assertEquals(0, commerce.CreditNote.unclaimed().count()) + + # Cannot refund this credit note as it is already applied. + with self.assertRaises(ValidationError): + cn.refund() + + def test_money_into_void_invoice_generates_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + invoice.void() + + val = invoice.invoice.value + + invoice.pay("Paying into the void.", val, pre_validate=False) + cn = self._credit_note_for_invoice(invoice.invoice) + self.assertEqual(val, cn.credit_note.value) + + def test_money_into_refunded_invoice_generates_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + val = invoice.invoice.value + + invoice.pay("Paying the first time.", val) + invoice.refund() + + cnval = val - 1 + invoice.pay("Paying into the void.", cnval, pre_validate=False) + + notes = commerce.CreditNote.objects.filter(invoice=invoice.invoice) + notes = sorted(notes, key=lambda note: note.value) + + self.assertEqual(cnval, notes[0].value) + self.assertEqual(val, notes[1].value) + + def test_money_into_paid_invoice_generates_credit_note(self): + invoice = self._invoice_containing_prod_1(1) + + val = invoice.invoice.value + + invoice.pay("Paying the first time.", val) + + invoice.pay("Paying into the void.", val, pre_validate=False) + cn = self._credit_note_for_invoice(invoice.invoice) + self.assertEqual(val, cn.credit_note.value) + + def test_invoice_with_credit_note_applied_is_refunded(self): + ''' Invoices with partial payments should void when cart is updated. + + Test for issue #64 -- applying a credit note to an invoice + means that invoice cannot be voided, and new invoices cannot be + created. ''' + + invoice = self._invoice_containing_prod_1(1) + + # Now get a credit note + invoice.pay("Lol", invoice.invoice.value) + invoice.refund() + cn = self._credit_note_for_invoice(invoice.invoice) + + # Create a cart of higher value than the credit note + cart = TestingCartController.for_user(self.USER_1) + cart.add_to_cart(self.PROD_1, 2) + + # Create a current invoice + # This will automatically apply `cn` to the invoice + invoice = TestingInvoiceController.for_cart(cart.cart) + + # Adding to cart will mean that the old invoice for this cart + # will be invalidated. A new invoice should be generated. + cart.add_to_cart(self.PROD_1, 1) + invoice = TestingInvoiceController.for_id(invoice.invoice.id) + invoice2 = TestingInvoiceController.for_cart(cart.cart) + cn2 = self._credit_note_for_invoice(invoice.invoice) + + invoice._refresh() + + # The first invoice should be refunded + self.assertEquals( + commerce.Invoice.STATUS_VOID, + invoice.invoice.status, + ) + + # Both credit notes should be for the same amount + self.assertEquals( + cn.credit_note.value, + cn2.credit_note.value, + ) + + def test_creating_invoice_automatically_applies_credit_note(self): + ''' Single credit note is automatically applied to new invoices. ''' + + invoice = self._invoice_containing_prod_1(1) + invoice.pay("boop", invoice.invoice.value) + invoice.refund() + + # Generate a new invoice to the same value as first invoice + # Should be paid, because we're applying credit notes automatically + invoice2 = self._invoice_containing_prod_1(1) + self.assertTrue(invoice2.invoice.is_paid) + + def _generate_multiple_credit_notes(self): + invoice1 = self._manual_invoice(11) + invoice2 = self._manual_invoice(11) + invoice1.pay("Pay", invoice1.invoice.value) + invoice1.refund() + invoice2.pay("Pay", invoice2.invoice.value) + invoice2.refund() + return invoice1.invoice.value + invoice2.invoice.value + + def test_mutiple_credit_notes_are_applied_when_generating_invoice_1(self): + ''' Tests (1) that multiple credit notes are applied to new invoice. + + Sum of credit note values will be *LESS* than the new invoice. + ''' + + notes_value = self._generate_multiple_credit_notes() + invoice = self._manual_invoice(notes_value + 1) + + self.assertEqual(notes_value, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_unpaid) + + user_unclaimed = commerce.CreditNote.unclaimed() + user_unclaimed = user_unclaimed.filter(invoice__user=self.USER_1) + self.assertEqual(0, user_unclaimed.count()) + + def test_mutiple_credit_notes_are_applied_when_generating_invoice_2(self): + ''' Tests (2) that multiple credit notes are applied to new invoice. + + Sum of credit note values will be *GREATER* than the new invoice. + ''' + + notes_value = self._generate_multiple_credit_notes() + invoice = self._manual_invoice(notes_value - 1) + + + self.assertEqual(notes_value - 1, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_paid) + + user_unclaimed = commerce.CreditNote.unclaimed().filter( + invoice__user=self.USER_1 + ) + self.assertEqual(1, user_unclaimed.count()) + + excess = self._credit_note_for_invoice(invoice.invoice) + self.assertEqual(excess.credit_note.value, 1) + + def test_credit_notes_are_left_over_if_not_all_are_needed(self): + ''' Tests that excess credit notes are untouched if they're not needed + ''' + + notes_value = self._generate_multiple_credit_notes() + notes_old = commerce.CreditNote.unclaimed().filter( + invoice__user=self.USER_1 + ) + + # Create a manual invoice whose value is smaller than any of the + # credit notes we created + invoice = self._manual_invoice(1) + notes_new = commerce.CreditNote.unclaimed().filter( + invoice__user=self.USER_1 + ) + + # Item is True if the note was't consumed when generating invoice. + note_was_unused = [(i in notes_old) for i in notes_new] + self.assertIn(True, note_was_unused) + + def test_credit_notes_are_not_applied_if_user_has_multiple_invoices(self): + + # Have an invoice pending with no credit notes; no payment will be made + invoice1 = self._invoice_containing_prod_1(1) + # Create some credit notes. + self._generate_multiple_credit_notes() + + invoice = self._manual_invoice(2) + + # Because there's already an invoice open for this user + # The credit notes are not automatically applied. + self.assertEqual(0, invoice.total_payments()) + self.assertTrue(invoice.invoice.is_unpaid) diff --git a/registrasion/tests/test_helpers.py b/registrasion/tests/test_helpers.py new file mode 100644 index 00000000..c656a2d0 --- /dev/null +++ b/registrasion/tests/test_helpers.py @@ -0,0 +1,26 @@ +import datetime + +from registrasion.models import commerce + +from controller_helpers import TestingCartController +from controller_helpers import TestingCreditNoteController +from controller_helpers import TestingInvoiceController + +class TestHelperMixin(object): + + def _invoice_containing_prod_1(self, qty=1): + cart = TestingCartController.for_user(self.USER_1) + cart.add_to_cart(self.PROD_1, qty) + + return TestingInvoiceController.for_cart(self.reget(cart.cart)) + + def _manual_invoice(self, value=1): + items = [("Item", value)] + due = datetime.timedelta(hours=1) + inv = TestingInvoiceController.manual_invoice(self.USER_1, due, items) + + return TestingInvoiceController(inv) + + def _credit_note_for_invoice(self, invoice): + note = commerce.CreditNote.objects.get(invoice=invoice) + return TestingCreditNoteController(note) diff --git a/registrasion/tests/test_invoice.py b/registrasion/tests/test_invoice.py index 4f73bf3c..6ae662a3 100644 --- a/registrasion/tests/test_invoice.py +++ b/registrasion/tests/test_invoice.py @@ -10,23 +10,14 @@ from registrasion.models import inventory from controller_helpers import TestingCartController from controller_helpers import TestingCreditNoteController from controller_helpers import TestingInvoiceController +from test_helpers import TestHelperMixin from test_cart import RegistrationCartTestCase UTC = pytz.timezone('UTC') -class InvoiceTestCase(RegistrationCartTestCase): - - def _invoice_containing_prod_1(self, qty=1): - cart = TestingCartController.for_user(self.USER_1) - cart.add_to_cart(self.PROD_1, qty) - - return TestingInvoiceController.for_cart(self.reget(cart.cart)) - - def _credit_note_for_invoice(self, invoice): - note = commerce.CreditNote.objects.get(invoice=invoice) - return TestingCreditNoteController(note) +class InvoiceTestCase(TestHelperMixin, RegistrationCartTestCase): def test_create_invoice(self): current_cart = TestingCartController.for_user(self.USER_1) @@ -238,268 +229,6 @@ class InvoiceTestCase(RegistrationCartTestCase): with self.assertRaises(ValidationError): invoice.validate_allowed_to_pay() - def test_overpaid_invoice_results_in_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - # Invoice is overpaid by 1 unit - to_pay = invoice.invoice.value + 1 - invoice.pay("Reference", to_pay) - - # The total paid should be equal to the value of the invoice only - self.assertEqual(invoice.invoice.value, invoice.total_payments()) - self.assertTrue(invoice.invoice.is_paid) - - # There should be a credit note generated out of the invoice. - credit_notes = commerce.CreditNote.objects.filter( - invoice=invoice.invoice, - ) - self.assertEqual(1, credit_notes.count()) - self.assertEqual(to_pay - invoice.invoice.value, credit_notes[0].value) - - def test_full_paid_invoice_does_not_generate_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - # Invoice is paid evenly - invoice.pay("Reference", invoice.invoice.value) - - # The total paid should be equal to the value of the invoice only - self.assertEqual(invoice.invoice.value, invoice.total_payments()) - self.assertTrue(invoice.invoice.is_paid) - - # There should be no credit notes - credit_notes = commerce.CreditNote.objects.filter( - invoice=invoice.invoice, - ) - self.assertEqual(0, credit_notes.count()) - - def test_refund_partially_paid_invoice_generates_correct_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - # Invoice is underpaid by 1 unit - to_pay = invoice.invoice.value - 1 - invoice.pay("Reference", to_pay) - invoice.refund() - - # The total paid should be zero - self.assertEqual(0, invoice.total_payments()) - self.assertTrue(invoice.invoice.is_void) - - # There should be a credit note generated out of the invoice. - credit_notes = commerce.CreditNote.objects.filter( - invoice=invoice.invoice, - ) - self.assertEqual(1, credit_notes.count()) - self.assertEqual(to_pay, credit_notes[0].value) - - def test_refund_fully_paid_invoice_generates_correct_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - to_pay = invoice.invoice.value - invoice.pay("Reference", to_pay) - self.assertTrue(invoice.invoice.is_paid) - - invoice.refund() - - # The total paid should be zero - self.assertEqual(0, invoice.total_payments()) - self.assertTrue(invoice.invoice.is_refunded) - - # There should be a credit note generated out of the invoice. - credit_notes = commerce.CreditNote.objects.filter( - invoice=invoice.invoice, - ) - self.assertEqual(1, credit_notes.count()) - self.assertEqual(to_pay, credit_notes[0].value) - - def test_apply_credit_note_pays_invoice(self): - invoice = self._invoice_containing_prod_1(1) - - to_pay = invoice.invoice.value - invoice.pay("Reference", to_pay) - self.assertTrue(invoice.invoice.is_paid) - - invoice.refund() - - # There should be one credit note generated out of the invoice. - cn = self._credit_note_for_invoice(invoice.invoice) - - # That credit note should be in the unclaimed pile - self.assertEquals(1, commerce.CreditNote.unclaimed().count()) - - # Create a new (identical) cart with invoice - cart = TestingCartController.for_user(self.USER_1) - cart.add_to_cart(self.PROD_1, 1) - - invoice2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) - - cn.apply_to_invoice(invoice2.invoice) - self.assertTrue(invoice2.invoice.is_paid) - - # That invoice should not show up as unclaimed any more - self.assertEquals(0, commerce.CreditNote.unclaimed().count()) - - def test_apply_credit_note_generates_new_credit_note_if_overpaying(self): - invoice = self._invoice_containing_prod_1(2) - - to_pay = invoice.invoice.value - invoice.pay("Reference", to_pay) - self.assertTrue(invoice.invoice.is_paid) - - invoice.refund() - - # There should be one credit note generated out of the invoice. - cn = self._credit_note_for_invoice(invoice.invoice) - - self.assertEquals(1, commerce.CreditNote.unclaimed().count()) - - # Create a new cart (of half value of inv 1) and get invoice - cart = TestingCartController.for_user(self.USER_1) - cart.add_to_cart(self.PROD_1, 1) - - invoice2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) - - cn.apply_to_invoice(invoice2.invoice) - self.assertTrue(invoice2.invoice.is_paid) - - # We generated a new credit note, and spent the old one, - # unclaimed should still be 1. - self.assertEquals(1, commerce.CreditNote.unclaimed().count()) - - credit_note2 = commerce.CreditNote.objects.get( - invoice=invoice2.invoice, - ) - - # The new credit note should be the residual of the cost of cart 1 - # minus the cost of cart 2. - self.assertEquals( - invoice.invoice.value - invoice2.invoice.value, - credit_note2.value, - ) - - def test_cannot_apply_credit_note_on_invalid_invoices(self): - invoice = self._invoice_containing_prod_1(1) - - to_pay = invoice.invoice.value - invoice.pay("Reference", to_pay) - self.assertTrue(invoice.invoice.is_paid) - - invoice.refund() - - # There should be one credit note generated out of the invoice. - cn = self._credit_note_for_invoice(invoice.invoice) - - # Create a new cart with invoice, pay it - invoice_2 = self._invoice_containing_prod_1(1) - invoice_2.pay("LOL", invoice_2.invoice.value) - - # Cannot pay paid invoice - with self.assertRaises(ValidationError): - cn.apply_to_invoice(invoice_2.invoice) - - invoice_2.refund() - # Cannot pay refunded invoice - with self.assertRaises(ValidationError): - cn.apply_to_invoice(invoice_2.invoice) - - # Create a new cart with invoice - invoice_2 = self._invoice_containing_prod_1(1) - invoice_2.void() - # Cannot pay void invoice - with self.assertRaises(ValidationError): - cn.apply_to_invoice(invoice_2.invoice) - - def test_cannot_apply_a_refunded_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - to_pay = invoice.invoice.value - invoice.pay("Reference", to_pay) - self.assertTrue(invoice.invoice.is_paid) - - invoice.refund() - - self.assertEquals(1, commerce.CreditNote.unclaimed().count()) - - cn = self._credit_note_for_invoice(invoice.invoice) - - cn.refund() - - # Refunding a credit note should mark it as claimed - self.assertEquals(0, commerce.CreditNote.unclaimed().count()) - - # Create a new cart with invoice - cart = TestingCartController.for_user(self.USER_1) - cart.add_to_cart(self.PROD_1, 1) - - invoice_2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) - - # Cannot pay with this credit note. - with self.assertRaises(ValidationError): - cn.apply_to_invoice(invoice_2.invoice) - - def test_cannot_refund_an_applied_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - to_pay = invoice.invoice.value - invoice.pay("Reference", to_pay) - self.assertTrue(invoice.invoice.is_paid) - - invoice.refund() - - self.assertEquals(1, commerce.CreditNote.unclaimed().count()) - - cn = self._credit_note_for_invoice(invoice.invoice) - - # Create a new cart with invoice - cart = TestingCartController.for_user(self.USER_1) - cart.add_to_cart(self.PROD_1, 1) - - invoice_2 = TestingInvoiceController.for_cart(self.reget(cart.cart)) - cn.apply_to_invoice(invoice_2.invoice) - - self.assertEquals(0, commerce.CreditNote.unclaimed().count()) - - # Cannot refund this credit note as it is already applied. - with self.assertRaises(ValidationError): - cn.refund() - - def test_money_into_void_invoice_generates_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - invoice.void() - - val = invoice.invoice.value - - invoice.pay("Paying into the void.", val, pre_validate=False) - cn = self._credit_note_for_invoice(invoice.invoice) - self.assertEqual(val, cn.credit_note.value) - - def test_money_into_refunded_invoice_generates_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - val = invoice.invoice.value - - invoice.pay("Paying the first time.", val) - invoice.refund() - - cnval = val - 1 - invoice.pay("Paying into the void.", cnval, pre_validate=False) - - notes = commerce.CreditNote.objects.filter(invoice=invoice.invoice) - notes = sorted(notes, key=lambda note: note.value) - - self.assertEqual(cnval, notes[0].value) - self.assertEqual(val, notes[1].value) - - def test_money_into_paid_invoice_generates_credit_note(self): - invoice = self._invoice_containing_prod_1(1) - - val = invoice.invoice.value - - invoice.pay("Paying the first time.", val) - - invoice.pay("Paying into the void.", val, pre_validate=False) - cn = self._credit_note_for_invoice(invoice.invoice) - self.assertEqual(val, cn.credit_note.value) - def test_required_category_constraints_prevent_invoicing(self): self.CAT_1.required = True self.CAT_1.save() @@ -534,52 +263,6 @@ class InvoiceTestCase(RegistrationCartTestCase): with self.assertRaises(ValidationError): invoice = TestingInvoiceController.for_cart(cart.cart) - def test_invoice_with_credit_note_applied_is_refunded(self): - ''' Invoices with partial payments should void when cart is updated. - - Test for issue #64 -- applying a credit note to an invoice - means that invoice cannot be voided, and new invoices cannot be - created. ''' - - cart = TestingCartController.for_user(self.USER_1) - - cart.add_to_cart(self.PROD_1, 1) - invoice = TestingInvoiceController.for_cart(cart.cart) - - # Now get a credit note - invoice.pay("Lol", invoice.invoice.value) - invoice.refund() - cn = self._credit_note_for_invoice(invoice.invoice) - - # Create a cart of higher value than the credit note - cart = TestingCartController.for_user(self.USER_1) - cart.add_to_cart(self.PROD_1, 2) - - # Create a current invoice, and apply partial payments - invoice = TestingInvoiceController.for_cart(cart.cart) - cn.apply_to_invoice(invoice.invoice) - - # Adding to cart will mean that the old invoice for this cart - # will be invalidated. A new invoice should be generated. - cart.add_to_cart(self.PROD_1, 1) - invoice = TestingInvoiceController.for_id(invoice.invoice.id) - invoice2 = TestingInvoiceController.for_cart(cart.cart) - cn2 = self._credit_note_for_invoice(invoice.invoice) - - invoice._refresh() - - # The first invoice should be refunded - self.assertEquals( - commerce.Invoice.STATUS_VOID, - invoice.invoice.status, - ) - - # Both credit notes should be for the same amount - self.assertEquals( - cn.credit_note.value, - cn2.credit_note.value, - ) - def test_can_generate_manual_invoice(self): description_price_pairs = [