def test_calculate_users_in_all_domains(self):
tasks.calculate_users_in_all_domains()
self.assertEqual(DomainUserHistory.objects.count(), 1)
domain_user_history = DomainUserHistory.objects.first()
self.assertEqual(domain_user_history.domain, self.domain.name)
self.assertEqual(domain_user_history.num_users, self.num_users)
self.assertEqual(domain_user_history.record_date, self.record_date)
def test_only_invoice_active_subscriptions(self):
"""
Test that only active subscriptions are invoiced.
Two subscriptions of the same plan only create one product line item and one set of feature line items
"""
invoice_date = utils.months_from_date(self.sub2.date_end, 1)
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('851.6200'))
self.assertEqual(invoice.account, self.account)
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 1)
num_feature_line_items = invoice.lineitem_set.get_features().count()
self.assertEqual(num_feature_line_items,
self.sub2.plan_version.feature_rates.count())
def test_multiple_subscription_invoice(self):
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertGreater(invoice.balance, Decimal('0.0000'))
self.assertEqual(invoice.account, self.account)
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 2)
num_feature_line_items = invoice.lineitem_set.get_features().count()
self.assertEqual(
num_feature_line_items,
self.subscription.plan_version.feature_rates.count() +
self.sub2.plan_version.feature_rates.count())
def test_product_line_items_in_yearly_invoice(self):
self.account.invoicing_plan = InvoicingPlan.YEARLY
self.account.save()
invoice_date = utils.months_from_date(self.subscription.date_start, 14)
for months_before_invoice_date in range(12):
user_date = date(invoice_date.year, invoice_date.month, 1)
user_date -= relativedelta.relativedelta(months=months_before_invoice_date)
calculate_users_in_all_domains(user_date)
tasks.generate_invoices(invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('18000.0000'))
self.assertEqual(invoice.account, self.account)
# There should be two product line items, with 3 months billed for each
num_product_line_items = invoice.lineitem_set.get_products().count()
self.assertEqual(num_product_line_items, 2)
for product_line_item in invoice.lineitem_set.get_products().all():
self.assertEqual(product_line_item.quantity, 12)
def test_account_level_sms_credits(self):
# Add SMS usage
arbitrary_sms_billables_for_domain(self.domain, self.sms_date,
self.sms_rate.monthly_limit + 1)
arbitrary_sms_billables_for_domain(
self.domain2,
self.sms_date,
num_sms=self.advanced_rate.monthly_limit + 10)
# Cover the cost of 1 SMS
CreditLine.add_credit(
amount=Decimal(0.5000),
feature_type=FeatureType.SMS,
account=self.account,
)
calculate_users_in_all_domains(self.invoice_date)
tasks.generate_invoices(self.invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('1507.7500'))
def test_account_level_user_credits(self):
# Add User usage
num_users = self.user_rate.monthly_limit + 10
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_users)
num_users_advanced = self.advanced_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain2.name,
num_users_advanced)
# Cover the cost of 1 User
CreditLine.add_credit(
amount=Decimal(2.0000),
feature_type=FeatureType.USER,
account=self.account,
)
calculate_users_in_all_domains(self.invoice_date)
tasks.generate_invoices(self.invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal(1509.0000))
def test_one_subscription_level_user_credit(self):
# Add User usage
num_users = self.user_rate.monthly_limit + 10
generator.arbitrary_commcare_users_for_domain(self.domain.name, num_users)
num_users_advanced = self.advanced_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain2.name, num_users_advanced)
# Cover the cost of 2 Users on the Advanced subscription
CreditLine.add_credit(
amount=Decimal(4.0000),
feature_type=FeatureType.USER,
subscription=self.sub2
)
invoice_date = utils.months_from_date(self.subscription.date_start,
random.randint(2, self.subscription_length))
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal(1507.0000))
def test_subscriptions_marked_do_not_invoice_not_included(self):
self.subscription.do_not_invoice = True
invoice_date = utils.months_from_date(self.sub2.date_end, 1)
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('1200.0000'))
self.assertEqual(invoice.account, self.account)
product_line_items = invoice.lineitem_set.get_products()
self.assertEqual(product_line_items.count(), 1)
self.assertEqual(
product_line_items.first().base_description,
'One month of CommCare Advanced Edition Software Plan.'
)
num_feature_line_items = invoice.lineitem_set.get_features().count()
self.assertEqual(num_feature_line_items, self.sub2.plan_version.feature_rates.count())
def test_over_limit(self):
num_users = self.user_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_users)
num_users_advanced = self.advanced_rate.monthly_limit + 1
generator.arbitrary_commcare_users_for_domain(self.domain2.name,
num_users_advanced)
calculate_users_in_all_domains(self.invoice_date)
tasks.generate_invoices(self.invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
user_line_items = invoice.lineitem_set.get_feature_by_type(
FeatureType.USER)
self.assertEqual(user_line_items.count(), 2)
for user_line_item in user_line_items:
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
num_to_charge = num_users - self.user_rate.monthly_limit
self.assertEqual(num_to_charge, user_line_item.quantity)
if self.user_rate.feature.name == user_line_item.feature_rate.feature.name:
self.assertEqual(user_line_item.unit_cost,
self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.total,
self.user_rate.per_excess_fee * num_to_charge)
self.assertEqual(user_line_item.subtotal,
self.user_rate.per_excess_fee * num_to_charge)
elif user_line_item.feature_rate.feature.name == self.advanced_rate.feature.name:
self.assertEqual(user_line_item.unit_cost,
self.advanced_rate.per_excess_fee)
self.assertEqual(
user_line_item.total,
self.advanced_rate.per_excess_fee * num_to_charge)
self.assertEqual(
user_line_item.subtotal,
self.advanced_rate.per_excess_fee * num_to_charge)
def test_under_limit(self):
"""
Make sure that the User rate produced:
- base_description is None
- base_cost is 0.0
- unit_cost is equal to the per_excess_fee
- quantity is equal to 0
- unit_description is None
- total and subtotals are 0.0
"""
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
num_users = lambda: random.randint(0, self.user_rate.monthly_limit)
num_active = num_users()
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_active)
num_inactive = num_users()
generator.arbitrary_commcare_users_for_domain(self.domain.name,
num_inactive,
is_active=False)
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
invoice = self.subscription.invoice_set.latest('date_created')
user_line_item = invoice.lineitem_set.get_feature_by_type(
FeatureType.USER).get()
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
self.assertIsNone(user_line_item.unit_description)
self.assertEqual(user_line_item.quantity, 0)
self.assertEqual(user_line_item.unit_cost,
self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.subtotal, Decimal('0.0000'))
self.assertEqual(user_line_item.total, Decimal('0.0000'))
def test_under_limit(self):
num_users = random.randint(0, self.user_rate.monthly_limit)
generator.arbitrary_commcare_users_for_domain(self.domain.name, num_users)
num_users_advanced = random.randint(0, self.advanced_rate.monthly_limit)
generator.arbitrary_commcare_users_for_domain(self.domain2.name, num_users_advanced)
calculate_users_in_all_domains(self.invoice_date)
tasks.generate_invoices(self.invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
self.assertEqual(invoice.balance, Decimal('1500.0000'))
user_line_items = invoice.lineitem_set.get_feature_by_type(FeatureType.USER)
self.assertEqual(user_line_items.count(), 2)
for user_line_item in user_line_items:
self.assertEqual(user_line_item.quantity, 0)
self.assertEqual(user_line_item.subtotal, Decimal('0.0000'))
self.assertEqual(user_line_item.total, Decimal('0.0000'))
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
self.assertIsNone(user_line_item.unit_description)
self.assertEqual(user_line_item.unit_cost, Decimal('1.0000'))
def test_community_over_limit(self):
"""
For a domain under community (no subscription) with users over the community limit, make sure that:
- base_description is None
- base_cost is 0.0
- unit_description is not None
- unit_cost is equal to the per_excess_fee on the user rate
- quantity is equal to number of commcare users in that domain minus the monthly_limit on the user rate
- total and subtotals are equal to number of extra users * per_excess_fee
"""
domain = generator.arbitrary_domain()
self.addCleanup(domain.delete)
num_active = generator.create_excess_community_users(domain)
account = BillingAccount.get_or_create_account_by_domain(
domain, created_by=self.dimagi_user)[0]
generator.arbitrary_contact_info(account, self.dimagi_user)
today = datetime.date.today()
account.date_confirmed_extra_charges = today
account.save()
calculate_users_in_all_domains(datetime.date(today.year, today.month, 1))
tasks.generate_invoices()
subscriber = Subscriber.objects.get(domain=domain.name)
invoice = Invoice.objects.filter(subscription__subscriber=subscriber).get()
user_line_item = invoice.lineitem_set.get_feature_by_type(FeatureType.USER).get()
self.assertIsNone(user_line_item.base_description)
self.assertEqual(user_line_item.base_cost, Decimal('0.0000'))
community_plan = DefaultProductPlan.get_default_plan_version()
num_to_charge = num_active - community_plan.user_limit
self.assertIsNotNone(user_line_item.unit_description)
self.assertEqual(user_line_item.quantity, num_to_charge)
self.assertEqual(user_line_item.unit_cost, self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.subtotal, num_to_charge * self.user_rate.per_excess_fee)
self.assertEqual(user_line_item.total, num_to_charge * self.user_rate.per_excess_fee)
def test_standard(self):
"""
For the Product Line Item, make sure that the Product rate is not prorated:
- base_cost uses the correct monthly fee
- base_description is not None
- unit_description is None
- unit_cost is 0.0
- quantity is 1
- subtotal = monthly fee
"""
invoice_date = utils.months_from_date(
self.subscription.date_start,
random.randint(2, self.subscription_length))
calculate_users_in_all_domains(invoice_date)
tasks.generate_invoices(invoice_date)
invoice = self.subscription.invoice_set.latest('date_created')
product_line_items = invoice.lineitem_set.filter(
feature_rate__exact=None)
self.assertEqual(product_line_items.count(), 1)
product_line_item = product_line_items.get()
self.assertIsNotNone(product_line_item.base_description)
self.assertEqual(product_line_item.base_cost,
self.product_rate.monthly_fee)
self.assertIsNone(product_line_item.unit_description)
self.assertEqual(product_line_item.unit_cost, Decimal('0.0000'))
self.assertEqual(product_line_item.quantity, 1)
self.assertEqual(product_line_item.subtotal,
self.product_rate.monthly_fee)
# no adjustments
self.assertEqual(product_line_item.total,
self.product_rate.monthly_fee)
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(invoice_date)
self.invoice = Invoice.objects.first()
def _create_sms_line_item(self):
calculate_users_in_all_domains(self.invoice_date)
tasks.generate_invoices(self.invoice_date)
invoice = self.subscription.invoice_set.latest('date_created')
return invoice.lineitem_set.get_feature_by_type(FeatureType.SMS).get()
def _create_sms_line_items(self):
calculate_users_in_all_domains(self.invoice_date)
tasks.generate_invoices(self.invoice_date)
self.assertEqual(CustomerInvoice.objects.count(), 1)
invoice = CustomerInvoice.objects.first()
return invoice.lineitem_set.get_feature_by_type(FeatureType.SMS)
