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), )