def setUpClass(cls):
super(BaseCustomerInvoiceCase, cls).setUpClass()
if cls.is_using_test_plans:
generator.bootstrap_test_software_plan_versions()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(
is_dimagi=True)
cls.account = generator.billing_account(cls.dimagi_user,
cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.account.is_customer_billing_account = True
cls.account.save()
cls.advanced_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
cls.advanced_plan.plan.is_customer_software_plan = True
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
advanced_subscription_end_date = add_months_to_date(
subscription_end_date, 2)
cls.domain2 = generator.arbitrary_domain()
cls.sub2 = generator.generate_domain_subscription(
cls.account,
cls.domain2,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan)
cls.domain3 = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan)
# This subscription should not be included in any customer invoices in these tests
cls.domain_community = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.COMMUNITY))
def setUpClass(cls):
super(BaseCustomerInvoiceCase, cls).setUpClass()
if cls.is_using_test_plans:
generator.bootstrap_test_software_plan_versions()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
cls.account = generator.billing_account(
cls.dimagi_user, cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.account.is_customer_billing_account = True
cls.account.save()
cls.advanced_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
cls.advanced_plan.plan.is_customer_software_plan = True
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
advanced_subscription_end_date = add_months_to_date(subscription_end_date, 2)
cls.domain2 = generator.arbitrary_domain()
cls.sub2 = generator.generate_domain_subscription(
cls.account,
cls.domain2,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan
)
cls.domain3 = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan
)
# This subscription should not be included in any customer invoices in these tests
cls.domain_community = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.COMMUNITY)
)
def add_domains_to_enterprise_account(account, domains, plan_version,
date_start):
for domain in domains:
generate_domain_subscription(
account,
domain,
date_start,
None,
plan_version=plan_version,
is_active=True,
)
def test_next_subscription(self):
this_subscription_date_end = self.subscription.date_end
already_canceled_future_subscription = generator.generate_domain_subscription( # noqa
self.account,
self.domain,
date_start=this_subscription_date_end,
date_end=this_subscription_date_end
)
next_future_subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=this_subscription_date_end,
date_end=add_months_to_date(this_subscription_date_end, 1),
)
self.assertEqual(self.subscription.next_subscription, next_future_subscription)
def test_next_subscription(self):
this_subscription_date_end = self.subscription.date_end
already_canceled_future_subscription = generator.generate_domain_subscription( # noqa
self.account,
self.domain,
date_start=this_subscription_date_end,
date_end=this_subscription_date_end)
next_future_subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=this_subscription_date_end,
date_end=add_months_to_date(this_subscription_date_end, 1),
)
self.assertEqual(self.subscription.next_subscription,
next_future_subscription)
def setUp(self):
super(TestBillingRecord, self).setUp()
self.billing_contact = generator.create_arbitrary_web_user_name()
self.dimagi_user = generator.create_arbitrary_web_user_name(
is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user,
self.billing_contact)
self.subscription_length = 4 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.invoice = Invoice(
subscription=self.subscription,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False,
)
self.billing_record = BillingRecord(invoice=self.invoice)
def test_date_due_set_large_invoice(self):
"""Date Due only gets set for a large invoice (> $100)"""
Subscription.objects.all().delete()
plan = DefaultProductPlan.objects.get(
edition=SoftwarePlanEdition.ADVANCED,
product_type=SoftwareProductType.COMMCARE,
is_trial=False).plan.get_version()
subscription_length = 5 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
subscription_length)
subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan)
invoice_date_large = utils.months_from_date(subscription.date_start, 3)
tasks.generate_invoices(invoice_date_large)
large_invoice = subscription.invoice_set.last()
self.assertTrue(large_invoice.balance > SMALL_INVOICE_THRESHOLD)
self.assertIsNotNone(large_invoice.date_due)
def setUpClass(cls):
super(TestEnterpriseSMSBillablesReport, cls).setUpClass()
cls.domain = 'test-domain'
cls.domain_obj = create_domain(cls.domain)
cls.user = WebUser.create(
cls.domain,
"test-user",
"123",
None,
None,
)
cls.account = generator.billing_account(cls.user,
"*****@*****.**")
cls.subscription_length = 15 # months
subscription_start_date = datetime(2021, 1, 1)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain_obj,
date_start=subscription_start_date,
date_end=None)
cls.subscription.is_active = True
cls.subscription.save()
cls.backend = SQLTestSMSBackend(
name="TEST",
is_global=True,
domain=cls.domain,
hq_api_id=SQLTestSMSBackend.get_api_id())
cls.backend.save()
def setUp(self):
super(TestBillingRecord, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription_length = 4 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.invoice = Invoice(
subscription=self.subscription,
date_start=self.invoice_start,
date_end=self.invoice_end,
is_hidden=False,
)
self.billing_record = BillingRecord(invoice=self.invoice)
def test_invoice_credit(self):
"""
Make sure that subscription and account level credits get applied to the invoice balance appropriately.
"""
invoice_monthly_total = self.product_rate.monthly_fee + self.monthly_user_fee
subscription_credit, account_credit = self._generate_subscription_and_account_invoice_credits(
invoice_monthly_total, self.subscription, self.account)
# other subscription credit that shouldn't count toward this invoice
other_domain = generator.arbitrary_domain()
# so that the other subscription doesn't draw from the same account credits, have it start 4 months later
new_subscription_start = utils.months_from_date(
self.subscription.date_start, 4)
other_subscription = generator.generate_domain_subscription(
self.account,
other_domain,
date_start=new_subscription_start,
date_end=add_months_to_date(new_subscription_start,
self.min_subscription_length),
)
# other account credit that shouldn't count toward this invoice
other_account = generator.billing_account(
self.dimagi_user, generator.arbitrary_web_user())
self._generate_subscription_and_account_invoice_credits(
invoice_monthly_total, other_subscription, other_account)
self._test_final_invoice_balance()
self._test_credit_use(subscription_credit)
self._test_credit_use(account_credit)
def test_date_due_gets_set_autopay(self):
"""Date due always gets set for autopay """
Subscription.objects.all().delete()
plan = DefaultProductPlan.objects.get(
edition=SoftwarePlanEdition.STANDARD,
product_type=SoftwareProductType.COMMCARE,
is_trial=False).plan.get_version()
subscription_length = 4
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
subscription_length)
autopay_subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan)
autopay_subscription.account.update_autopay_user(
self.billing_contact.username, self.domain)
invoice_date_autopay = utils.months_from_date(
autopay_subscription.date_start, 1)
tasks.generate_invoices(invoice_date_autopay)
autopay_invoice = autopay_subscription.invoice_set.last()
self.assertTrue(autopay_invoice.balance <= SMALL_INVOICE_THRESHOLD)
self.assertIsNotNone(autopay_invoice.date_due)
def _generate_non_autopayable_entities(cls):
"""
Create account, domain, and subscription linked to the autopay user, but that don't have autopay enabled
"""
cls.non_autopay_account = generator.billing_account(
web_user_creator=generator.create_arbitrary_web_user_name(
is_dimagi=True),
web_user_contact=cls.autopay_user_email)
cls.non_autopay_domain = generator.arbitrary_domain()
# Non-autopay subscription has same parameters as the autopayable subscription
cheap_plan = SoftwarePlan.objects.create(name='cheap')
cheap_product_rate = SoftwareProductRate.objects.create(
monthly_fee=100, name=cheap_plan.name)
cheap_plan_version = SoftwarePlanVersion.objects.create(
plan=cheap_plan,
product_rate=cheap_product_rate,
role=Role.objects.first(),
)
cls.non_autopay_subscription = generator.generate_domain_subscription(
cls.non_autopay_account,
cls.non_autopay_domain,
plan_version=cheap_plan_version,
date_start=cls.subscription.date_start,
date_end=add_months_to_date(cls.subscription.date_start,
cls.subscription_length),
)
def test_date_due_not_set_small_invoice(self):
"""Date Due doesn't get set if the invoice is small"""
Subscription.objects.all().delete()
plan = DefaultProductPlan.objects.get(
edition=SoftwarePlanEdition.STANDARD,
product_type=SoftwareProductType.COMMCARE,
is_trial=False).plan.get_version()
subscription_length = 5 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
subscription_length)
subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan,
)
invoice_date_small = utils.months_from_date(subscription.date_start, 1)
tasks.generate_invoices(invoice_date_small)
small_invoice = subscription.invoice_set.first()
self.assertTrue(small_invoice.balance <= SMALL_INVOICE_THRESHOLD)
self.assertIsNone(small_invoice.date_due)
def test_invoice_credit(self):
"""
Make sure that subscription and account level credits get applied to the invoice balance appropriately.
"""
invoice_monthly_total = self.product_rate.monthly_fee + self.monthly_user_fee
subscription_credit, account_credit = self._generate_subscription_and_account_invoice_credits(
invoice_monthly_total, self.subscription, self.account
)
# other subscription credit that shouldn't count toward this invoice
other_domain = generator.arbitrary_domain()
# so that the other subscription doesn't draw from the same account credits, have it start 4 months later
new_subscription_start = utils.months_from_date(self.subscription.date_start, 4)
other_subscription = generator.generate_domain_subscription(
self.account,
other_domain,
date_start=new_subscription_start,
date_end=add_months_to_date(new_subscription_start, self.min_subscription_length),
)
# other account credit that shouldn't count toward this invoice
other_account = generator.billing_account(self.dimagi_user, generator.create_arbitrary_web_user_name())
self._generate_subscription_and_account_invoice_credits(
invoice_monthly_total, other_subscription, other_account
)
self._test_final_invoice_balance()
self._test_credit_use(subscription_credit)
self._test_credit_use(account_credit)
other_domain.delete()
def setUpClass(cls):
super(BaseCustomerInvoiceCase, cls).setUpClass()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(
is_dimagi=True)
cls.account = generator.billing_account(cls.dimagi_user,
cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.account.is_customer_billing_account = True
cls.account.save()
cls.advanced_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
cls.advanced_plan.plan.is_customer_software_plan = True
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date,
cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
cls.subscription.plan_version.plan.is_customer_software_plan = True
advanced_subscription_end_date = add_months_to_date(
subscription_end_date, 2)
cls.domain2 = generator.arbitrary_domain()
cls.sub2 = generator.generate_domain_subscription(
cls.account,
cls.domain2,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan)
cls.sub2.plan_version.plan.is_customer_software_plan = True
cls.domain3 = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan)
cls.sub3.plan_version.plan.is_customer_software_plan = True
def setUpClass(cls):
super(BaseCustomerInvoiceCase, cls).setUpClass()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
cls.account = generator.billing_account(
cls.dimagi_user, cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.account.is_customer_billing_account = True
cls.account.save()
cls.advanced_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
cls.advanced_plan.plan.is_customer_software_plan = True
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
cls.subscription.plan_version.plan.is_customer_software_plan = True
advanced_subscription_end_date = add_months_to_date(subscription_end_date, 2)
cls.domain2 = generator.arbitrary_domain()
cls.sub2 = generator.generate_domain_subscription(
cls.account,
cls.domain2,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan
)
cls.sub2.plan_version.plan.is_customer_software_plan = True
cls.domain3 = generator.arbitrary_domain()
cls.sub3 = generator.generate_domain_subscription(
cls.account,
cls.domain3,
date_start=subscription_start_date,
date_end=advanced_subscription_end_date,
plan_version=cls.advanced_plan
)
cls.sub3.plan_version.plan.is_customer_software_plan = True
def test_deleted_domain_in_multiple_subscription_invoice(self):
invoice_date = utils.months_from_date(self.subscription.date_start, 2)
domain_to_be_deleted = generator.arbitrary_domain()
generator.generate_domain_subscription(self.account,
domain_to_be_deleted,
date_start=self.sub2.date_start,
date_end=self.sub2.date_end,
plan_version=self.advanced_plan)
domain_to_be_deleted.delete(leave_tombstone=True)
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 2)
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(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 _generate_non_autopayable_entities(self):
"""
Create account, domain, and subscription linked to the autopay user, but that don't have autopay enabled
"""
self.non_autopay_account = generator.billing_account(
web_user_creator=generator.arbitrary_web_user(is_dimagi=True),
web_user_contact=self.autopay_user)
self.non_autopay_domain = generator.arbitrary_domain()
# Non-autopay subscription has same parameters as the autopayable subscription
self.non_autopay_subscription = generator.generate_domain_subscription(
self.non_autopay_account,
self.non_autopay_domain,
date_start=self.subscription.date_start,
date_end=add_months_to_date(self.subscription.date_start,
self.subscription_length),
)
def _generate_non_autopayable_entities(self):
"""
Create account, domain, and subscription linked to the autopay user, but that don't have autopay enabled
"""
self.non_autopay_account = generator.billing_account(
web_user_creator=generator.arbitrary_web_user(is_dimagi=True),
web_user_contact=self.autopay_user
)
self.non_autopay_domain = generator.arbitrary_domain()
# Non-autopay subscription has same parameters as the autopayable subscription
self.non_autopay_subscription = generator.generate_domain_subscription(
self.non_autopay_account,
self.non_autopay_domain,
date_start=self.subscription.date_start,
date_end=add_months_to_date(self.subscription.date_start, self.subscription_length),
)
def setUp(self):
super(TestSubscription, self).setUp()
self.billing_contact = generator.create_arbitrary_web_user_name()
self.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
def setUp(self):
super(TestSubscription, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.domain = Domain(name='test')
self.domain.save()
self.currency = generator.init_default_currency()
self.account = generator.billing_account(self.dimagi_user, self.billing_contact)
self.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
def setUpClass(cls):
super(BaseInvoiceTestCase, cls).setUpClass()
generator.bootstrap_test_plans() # TODO - only call for subclasses that actually need the test plans
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
cls.currency = generator.init_default_currency()
cls.account = generator.billing_account(
cls.dimagi_user, cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
def setUp(self):
super(TestContractedInvoices, self).setUp()
generator.delete_all_subscriptions()
self.subscription_length = self.min_subscription_length
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
service_type=SubscriptionType.IMPLEMENTATION,
)
self.invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length)
)
def setUp(self):
super(TestContractedInvoices, self).setUp()
generator.delete_all_subscriptions()
self.subscription_length = self.min_subscription_length
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
service_type=SubscriptionType.IMPLEMENTATION,
)
self.invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length)
)
def setUp(self):
super(BaseInvoiceTestCase, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.currency = generator.init_default_currency()
self.account = generator.billing_account(
self.dimagi_user, self.billing_contact)
self.domain = generator.arbitrary_domain()
self.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.community_plan = DefaultProductPlan.get_default_plan_version()
def setUp(self):
super(BaseInvoiceTestCase, self).setUp()
self.billing_contact = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.currency = generator.init_default_currency()
self.account = generator.billing_account(
self.dimagi_user, self.billing_contact)
self.domain = generator.arbitrary_domain()
self.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, self.subscription_length)
self.subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
self.community_plan = DefaultProductPlan.get_default_plan_version()
def create_enterprise_permissions(email,
source_domain,
domains=None,
other_domains=None):
"""
Creates an account using the given email address and sets up enterprise permissions
with the given source domain. Both `domains` and `other_domains` are added to the new account,
but only `domains` are controlled by enterprise permissions.
All given domains must exist.
"""
account = generator.billing_account(email, email, is_customer_account=True)
plan_version = generator.subscribable_plan_version(
edition=SoftwarePlanEdition.ENTERPRISE)
start_date = datetime.now().date()
end_date = start_date + timedelta(days=365)
subscriptions = []
all_domains = [source_domain]
if domains:
all_domains.extend(domains)
if other_domains:
all_domains.extend(other_domains)
for domain in all_domains:
subscriptions.append(
generator.generate_domain_subscription(
account,
Domain.get_by_name(domain),
date_start=start_date,
date_end=end_date,
plan_version=plan_version,
is_active=True,
))
EnterprisePermissions(
account=account,
is_enabled=True,
source_domain=source_domain,
domains=domains,
).save()
def setUpClass(cls):
super(BaseInvoiceTestCase, cls).setUpClass()
if cls.is_using_test_plans:
generator.bootstrap_test_software_plan_versions()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
cls.currency = generator.init_default_currency()
cls.account = generator.billing_account(
cls.dimagi_user, cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
def test_date_due_set_large_invoice(self):
"""Date Due only gets set for a large invoice (> $100)"""
Subscription.objects.all().delete()
plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.ADVANCED)
subscription_length = 5 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, subscription_length)
subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan_version
)
invoice_date_large = utils.months_from_date(subscription.date_start, 3)
tasks.generate_invoices(invoice_date_large)
large_invoice = subscription.invoice_set.last()
self.assertTrue(large_invoice.balance > SMALL_INVOICE_THRESHOLD)
self.assertIsNotNone(large_invoice.date_due)
def test_date_due_not_set_small_invoice(self):
"""Date Due doesn't get set if the invoice is small"""
Subscription.objects.all().delete()
plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.STANDARD)
subscription_length = 5 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, subscription_length)
subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan_version,
)
invoice_date_small = utils.months_from_date(subscription.date_start, 1)
tasks.generate_invoices(invoice_date_small)
small_invoice = subscription.invoice_set.first()
self.assertTrue(small_invoice.balance <= SMALL_INVOICE_THRESHOLD)
self.assertIsNone(small_invoice.date_due)
def setUpClass(cls):
super(BaseInvoiceTestCase, cls).setUpClass()
if cls.is_using_test_plans:
generator.bootstrap_test_software_plan_versions()
cls.billing_contact = generator.create_arbitrary_web_user_name()
cls.dimagi_user = generator.create_arbitrary_web_user_name(is_dimagi=True)
cls.currency = generator.init_default_currency()
cls.account = generator.billing_account(
cls.dimagi_user, cls.billing_contact)
cls.domain = generator.arbitrary_domain()
cls.subscription_length = 15 # months
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, cls.subscription_length)
cls.subscription = generator.generate_domain_subscription(
cls.account,
cls.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
)
def test_date_due_gets_set_autopay(self):
"""Date due always gets set for autopay """
Subscription.objects.all().delete()
plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.STANDARD)
subscription_length = 4
subscription_start_date = datetime.date(2016, 2, 23)
subscription_end_date = add_months_to_date(subscription_start_date, subscription_length)
autopay_subscription = generator.generate_domain_subscription(
self.account,
self.domain,
date_start=subscription_start_date,
date_end=subscription_end_date,
plan_version=plan_version
)
autopay_subscription.account.update_autopay_user(self.billing_contact.username, self.domain)
invoice_date_autopay = utils.months_from_date(autopay_subscription.date_start, 1)
tasks.generate_invoices(invoice_date_autopay)
autopay_invoice = autopay_subscription.invoice_set.last()
self.assertTrue(autopay_invoice.balance <= SMALL_INVOICE_THRESHOLD)
self.assertIsNotNone(autopay_invoice.date_due)
def _generate_non_autopayable_entities(cls):
"""
Create account, domain, and subscription linked to the autopay user, but that don't have autopay enabled
"""
cls.non_autopay_account = generator.billing_account(
web_user_creator=generator.create_arbitrary_web_user_name(is_dimagi=True),
web_user_contact=cls.autopay_user_email
)
cls.non_autopay_domain = generator.arbitrary_domain()
# Non-autopay subscription has same parameters as the autopayable subscription
cheap_plan = SoftwarePlan.objects.create(name='cheap')
cheap_product_rate = SoftwareProductRate.objects.create(monthly_fee=100, name=cheap_plan.name)
cheap_plan_version = SoftwarePlanVersion.objects.create(
plan=cheap_plan,
product_rate=cheap_product_rate,
role=Role.objects.first(),
)
cls.non_autopay_subscription = generator.generate_domain_subscription(
cls.non_autopay_account,
cls.non_autopay_domain,
plan_version=cheap_plan_version,
date_start=cls.subscription.date_start,
date_end=add_months_to_date(cls.subscription.date_start, cls.subscription_length),
)
