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)