def _generate_invoices(cls):
"""
Create invoices for both autopayable and non-autopayable subscriptions
"""
# invoice date is 2 months before the end of the subscription (this is arbitrary)
invoice_date = utils.months_from_date(cls.subscription.date_start,
cls.subscription_length - 2)
tasks.calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices_based_on_date(invoice_date)
def _test_final_invoice_balance(self):
for month_num in range(2, 5):
invoice_date = utils.months_from_date(self.subscription.date_start,
month_num)
tasks.calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices_based_on_date(invoice_date)
invoice = self.subscription.invoice_set.latest('date_end')
if month_num < 4:
# the first two invoices for the line item should be covered by its credit line
self.assertEqual(invoice.balance, Decimal('0.0000'))
else:
self.assertNotEqual(invoice.balance, Decimal('0.0000'))
def _generate_invoice_and_subscription(days_ago,
is_customer_billing_account=False):
"""
:param days_ago: The number of days ago an invoice should be due
:return: random domain, with invoices generated on the backend
"""
invoice_due_date = datetime.date.today() - datetime.timedelta(
days=days_ago)
billing_contact = generator.create_arbitrary_web_user_name()
dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
account = generator.billing_account(dimagi_user, billing_contact)
account.is_customer_billing_account = is_customer_billing_account
account.save()
domain = generator.arbitrary_domain()
subscription_start_date = utils.months_from_date(invoice_due_date, -2)
subscription = generator.generate_domain_subscription(
account,
domain,
date_start=subscription_start_date,
date_end=None,
plan_version=DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.ADVANCED),
service_type=SubscriptionType.PRODUCT,
)
subscription.is_active = True
subscription.save()
invoice_date = utils.months_from_date(invoice_due_date, -1)
DomainUserHistory.objects.create(domain=domain.name,
num_users=20,
record_date=invoice_date -
datetime.timedelta(days=1))
tasks.generate_invoices_based_on_date(invoice_date)
# for testing purposes, force the latest invoice due_date to be
# the "invoice_due_date" specified above
if is_customer_billing_account:
latest_invoice = CustomerInvoice.objects.filter(
account=account, ).latest('date_created')
else:
latest_invoice = subscription.invoice_set.latest('date_created')
latest_invoice.date_due = invoice_due_date
latest_invoice.save()
return domain, latest_invoice
def _test_line_item_crediting(self, get_line_item_from_invoice):
"""
Tests line item credits for three invoicing periods.
"""
for month_num in range(2, 5):
invoice_date = utils.months_from_date(self.subscription.date_start,
month_num)
tasks.calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices_based_on_date(invoice_date)
invoice = self.subscription.invoice_set.latest('date_end')
line_item = get_line_item_from_invoice(invoice)
if month_num < 4:
# the first two invoices for the line item should be covered by its credit line
self.assertEqual(line_item.total, Decimal('0.0000'))
else:
self.assertNotEqual(line_item.total, Decimal('0.0000'))
def test_subscription_credits_transfer_in_invoice(self):
standard_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD)
pro_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.PRO)
first_sub = Subscription.new_domain_subscription(
self.account,
self.domain.name,
standard_plan,
date_start=datetime.date(2019, 9, 1),
)
credit_amount = Decimal('5000.00')
CreditLine.add_credit(
credit_amount,
subscription=first_sub,
)
# this is the key step where the expected transfer happens
second_sub = first_sub.change_plan(pro_plan)
first_sub = Subscription.visible_objects.get(id=first_sub.id)
first_sub.date_end = datetime.date(2019, 9, 10)
first_sub.save()
second_sub.date_start = first_sub.date_end
second_sub.save()
invoice_date = utils.months_from_date(first_sub.date_start, 1)
user_record_date = invoice_date - relativedelta(days=1)
DomainUserHistory.objects.create(domain=self.domain,
num_users=0,
record_date=user_record_date)
tasks.generate_invoices_based_on_date(
utils.months_from_date(first_sub.date_start, 1))
self.assertEqual(first_sub.invoice_set.count(), 1)
self.assertEqual(second_sub.invoice_set.count(), 1)
first_invoice = first_sub.invoice_set.first()
second_invoice = second_sub.invoice_set.first()
self.assertEqual(first_invoice.balance, Decimal('0.0000'))
self.assertEqual(second_invoice.balance, Decimal('0.0000'))
self.assertEqual(self._get_credit_total(second_sub),
Decimal('4490.0000'))
def setUp(self):
super(TestAdjustBalanceForm, self).setUp()
invoice_date = self.subscription.date_start + relativedelta(months=1)
calculate_users_in_all_domains(datetime.date(invoice_date.year, invoice_date.month, 1))
generate_invoices_based_on_date(invoice_date)
self.invoice = Invoice.objects.first()