def test_balance_on_date(self): import pytz start_date = dt.datetime(2019, 1, 1, 0, 0, 0, 0, tzinfo=pytz.UTC) invoice_date = dt.datetime(2019, 1, 15, 0, 0, 0, 0, tzinfo=pytz.UTC) payment_date = dt.datetime(2019, 1, 17, 0, 0, 0, 0, tzinfo=pytz.UTC) mid_date = dt.datetime(2019, 1, 20, 0, 0, 0, 0, tzinfo=pytz.UTC) from silver.overpayment_checker import OverpaymentChecker # 0 for easy asserting. customer = CustomerFactory(sales_tax_percent=0, currency='USD', first_name="Bob", last_name="Smith") customer.save() assert customer.balance_on_date(date=start_date) == Decimal(0) ## Now we create an invoice situation after the start date... # Create customer payment method payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False) payment_method.save() # Create a simple invoice entry = DocumentEntryFactory(quantity=1, unit_price=150) entry.save() invoice = InvoiceFactory.create(invoice_entries=[entry], due_date=invoice_date, customer=customer, transaction_currency='USD') invoice.issue() invoice.save() # Customer overpays by 2x transaction = TransactionFactory.create( invoice=invoice, payment_method=payment_method, created_at=payment_date, updated_at=payment_date, overpayment=True, amount=300, state=Transaction.States.Initial) transaction.settle() transaction.save() invoice.pay() assert invoice.state == Invoice.STATES.PAID assert customer.balance_on_date(date=start_date) == Decimal(0) assert customer.balance_on_date(date=payment_date) == Decimal(0) # This balance should be 150, but it's not yet. assert customer.balance_on_date(date=mid_date) == Decimal(150) return # Grab the overpayment defaults op = OverpaymentChecker() # Run the overpayment process call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) # An invoice has been issued a for the correct amount. repayment = Invoice.objects.filter( provider=op.default_provider).first() assert Invoice.objects.filter( provider=op.default_provider).count() == 1 assert repayment.total_in_transaction_currency == -150 assert repayment.state == Invoice.STATES.ISSUED # Customer balance is still the same; payment has not occurred # yet. assert customer.balance == Decimal(150) # Run the overpayment process a couple more times, does it duplicate # things? call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) assert Invoice.objects.filter( provider=op.default_provider).count() == 1 assert repayment.total_in_transaction_currency == -150 assert repayment.state == Invoice.STATES.ISSUED # Customer balance is still the same; payment has not occurred # yet. assert customer.balance == Decimal(150) # Create the repayment transaction, this is supposed to happen # somewhere automatically. amt = repayment.total_in_transaction_currency repayment_tx = Transaction.objects.create( invoice=repayment, amount=amt, overpayment=True, state=Transaction.States.Initial, payment_method=payment_method) repayment_tx.settle() repayment_tx.save() # There's one transaction issued for this doc, and it has set # the state of the invoice to PAID. The customer's balance is # now 0. assert repayment.state == Invoice.STATES.PAID assert repayment.transactions.count() == 1 assert repayment.amount_paid_in_transaction_currency == -150 assert repayment.customer.balance == Decimal(0)
def test_customer_balance_gte_zero(self): """ Create a zero and positive balance, and rerun the overpayment process: no invoices should be issued. """ from silver.overpayment_checker import OverpaymentChecker # 0 for easy asserting. customer = CustomerFactory(sales_tax_percent=0, currency='USD', first_name="Bob", last_name="Smith") customer.save() # Create customer payment method payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False) payment_method.save() # Create a simple invoice entry = DocumentEntryFactory(quantity=1, unit_price=150) entry.save() invoice = InvoiceFactory.create(invoice_entries=[entry], customer=customer, transaction_currency='USD') invoice.issue() invoice.save() # Customer pays an accurate amount. transaction = TransactionFactory.create( invoice=invoice, payment_method=payment_method, amount=150, state=Transaction.States.Initial) transaction.settle() transaction.save() assert invoice.state == Invoice.STATES.PAID assert Invoice.objects.filter(customer=customer).count() == 1 assert customer.balance == Decimal(0) # Run the overpayment process call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) provider = OverpaymentChecker().default_provider assert Invoice.objects.filter(provider=provider).count() == 0 # Run the overpayment process a couple more times, does it duplicate # things? call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) assert Invoice.objects.filter(provider=provider).count() == 0
def test_correct_overpayment(self): """ An invoice is issued, and it is overpaid. A correction is issued """ # 0 for easy asserting. customer = CustomerFactory(sales_tax_percent=0, currency='USD', first_name="Bob", last_name="Smith") customer.save() payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False) # Create a simple invoice entry = DocumentEntryFactory(quantity=1, unit_price=150) invoice = InvoiceFactory.create(invoice_entries=[entry], customer=customer, transaction_currency='USD') invoice.issue() invoice.save() assert PaymentMethod.objects.count() == 1 assert Invoice.objects.count() == 1 assert BillingDocumentBase.objects.count() == 1 # Customer overpays by 2x transaction = TransactionFactory.create( invoice=invoice, payment_method=payment_method, overpayment=True, amount=300, state=Transaction.States.Initial) transaction.settle() transaction.save() invoice.pay() assert invoice.state == Invoice.STATES.PAID assert PaymentMethod.objects.count() == 1 assert Invoice.objects.count() == 1 # Proforma issued as well assert BillingDocumentBase.objects.count() == 2 assert customer.balance == Decimal(150) # # Create a repayment invoice entry = DocumentEntryFactory(quantity=1, unit_price=-150) invoice = InvoiceFactory.create(invoice_entries=[entry], customer=customer, state=Invoice.STATES.DRAFT, transaction_currency='USD') invoice.save() assert customer.balance == Decimal(150) invoice.issue() invoice.save() assert customer.balance == Decimal(150) # This is the transaction to correct the balance. We're using # .settle() here, but we will need another method (forthcoming). transaction = TransactionFactory.create( invoice=invoice, payment_method=payment_method, overpayment=True, amount=-150, state=Transaction.States.Initial) transaction.settle() transaction.save() assert invoice.state == Invoice.STATES.PAID assert customer.balance == Decimal(0)
def test_overpayment_checker_process(self): from silver.overpayment_checker import OverpaymentChecker customer = CustomerFactory( sales_tax_percent=0, # 0 for easy asserting. currency='USD', first_name="Bob", last_name="Smith") customer.save() # Create customer payment method # payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False) payment_method.save() # Create a simple invoice. # entry = DocumentEntryFactory(quantity=1, unit_price=150) entry.save() invoice = InvoiceFactory.create(invoice_entries=[entry], customer=customer, transaction_currency='USD') invoice.issue() invoice.save() # Customer overpays by 2x # transaction = TransactionFactory.create( invoice=invoice, payment_method=payment_method, overpayment=True, amount=300, state=Transaction.States.Initial) transaction.settle() transaction.save() invoice.pay() assert invoice.state == Invoice.STATES.PAID assert customer.balance == Decimal(150) # Grab the overpayment defaults op = OverpaymentChecker() # Run the overpayment process call_command('check_overpayments', billing_date=timezone.now().date(), stdout=self.output) # An invoice has been issued a for the correct amount. repayment = Invoice.objects.filter( provider=op.default_provider).first() assert Invoice.objects.filter( provider=op.default_provider).count() == 1 assert repayment.total_in_transaction_currency == -150 assert repayment.state == Invoice.STATES.ISSUED # Customer balance is still the same; payment has not occurred # yet. # assert customer.balance == Decimal(150) # Create the repayment transaction, this is supposed to happen # somewhere automatically. # repayment_tx = Transaction.objects.create( invoice=repayment, amount=repayment.total_in_transaction_currency, overpayment=True, state=Transaction.States.Initial, payment_method=payment_method) repayment_tx.settle() repayment_tx.save() # There's one transaction issued for this doc, and it has set # the state of the invoice to PAID. The customer's balance is # now 0. # assert repayment.state == Invoice.STATES.PAID assert repayment.transactions.count() == 1 assert repayment.amount_paid_in_transaction_currency == -150 assert repayment.customer.balance == Decimal(0)
def test_customer_balance_calculation_with_overpayments(self): """ An invoice is issued, and it is paid in two transactions: one for half the amount, and another for well over the amount. """ # 0 for easy asserting. customer = CustomerFactory(sales_tax_percent=0, currency='USD', first_name="Bob", last_name="Smith") customer.save() payment_method = PaymentMethodFactory.create( payment_processor=triggered_processor, customer=customer, canceled=False) # Create a simple invoice entry = DocumentEntryFactory(quantity=1, unit_price=250) invoice = InvoiceFactory.create(invoice_entries=[entry], customer=customer) invoice.issue() # Customer underpays by half transaction = TransactionFactory.create( invoice=invoice, payment_method=payment_method, amount=125.00, state=Transaction.States.Initial) transaction.settle() transaction.save() assert invoice.state != Invoice.STATES.PAID # Customer overpays by double transaction_over = TransactionFactory.create( invoice=invoice, payment_method=payment_method, amount=500, # NB: overpayment=True, state=Transaction.States.Initial) transaction_over.settle() transaction_over.save() assert invoice.state != Invoice.STATES.PAID invoice.pay() assert invoice.state == Invoice.STATES.PAID # Payment calculation works even with overpayment. assert invoice.amount_paid_in_transaction_currency == \ ((invoice.total_in_transaction_currency / 2) + \ (invoice.total_in_transaction_currency * 2)) # Customer paid 625 total, for an invoice of 250 # Current balance: 375.00 overpayment = abs( invoice.total_in_transaction_currency - \ ((invoice.total_in_transaction_currency / 2) + \ (invoice.total_in_transaction_currency * 2)) ) assert invoice.total_in_transaction_currency == 250.00 assert overpayment == Decimal(375.00) assert customer.balance == overpayment