def test_patchy_coverage(self): some_plan = generator.subscribable_plan_version() middle_date = self.invoice_end - datetime.timedelta(days=15) Subscription.new_domain_subscription( self.account, self.domain.name, some_plan, date_start=self.invoice_start + datetime.timedelta(days=1), date_end=middle_date ) next_start = middle_date + datetime.timedelta(days=2) next_end = next_start + datetime.timedelta(days=2) Subscription.new_domain_subscription( self.account, self.domain.name, some_plan, date_start=next_start, date_end=next_end, ) final_start = next_end + datetime.timedelta(days=2) Subscription.new_domain_subscription( self.account, self.domain.name, some_plan, date_start=final_start, date_end=self.invoice_end - datetime.timedelta(days=1), ) subscriptions = self.invoice_factory._get_subscriptions() self.assertEqual(len(subscriptions), 3) community_ranges = self.invoice_factory._get_community_ranges(subscriptions) self.assertEqual(len(community_ranges), 4)
def test_clean(self): account = BillingAccount.objects.create( name='Test Account', created_by='*****@*****.**', currency=generator.init_default_currency(), ) subscription = Subscription.visible_objects.create( account=account, date_start=date.today(), plan_version=generator.subscribable_plan_version(), subscriber=Subscriber.objects.create(domain='test') ) invoice = Invoice.objects.create( date_start=date.today(), date_end=date.today(), subscription=subscription, ) line_item = LineItem.objects.create( invoice=invoice, ) with self.assertRaises(ValidationError): try: CreditAdjustment( invoice=invoice, line_item=line_item, ).save() except ValidationError as e: self.assertIn('__all__', e.error_dict) raise e
def test_date_due_set_large_invoice(self): """Date Due only gets set for a large invoice (> $100)""" self.subscription.plan_version = generator.subscribable_plan_version(SoftwarePlanEdition.ADVANCED) self.subscription.save() invoice_date_large = utils.months_from_date(self.subscription.date_start, 3) tasks.generate_invoices(invoice_date_large) large_invoice = self.subscription.invoice_set.last() self.assertTrue(large_invoice.balance > SMALL_INVOICE_THRESHOLD) self.assertIsNotNone(large_invoice.date_due)
def test_full_coverage(self): some_plan = generator.subscribable_plan_version() Subscription.new_domain_subscription( self.account, self.domain.name, some_plan, date_start=self.invoice_start, date_end=self.invoice_end + datetime.timedelta(days=1), ) subscriptions = self.invoice_factory._get_subscriptions() community_ranges = self.invoice_factory._get_community_ranges(subscriptions) self.assertEqual(len(community_ranges), 0)
def test_incomplete_starting_coverage(self): some_plan = generator.subscribable_plan_version() subscription = Subscription.new_domain_subscription( self.account, self.domain.name, some_plan, date_start=self.invoice_start + datetime.timedelta(days=3) ) subscriptions = self.invoice_factory._get_subscriptions() community_ranges = self.invoice_factory._get_community_ranges(subscriptions) self.assertEqual(len(community_ranges), 1) self.assertEqual(community_ranges[0][0], self.invoice_start) self.assertEqual(community_ranges[0][1], subscription.date_start)
def test_paused_plan_generates_no_invoice(self): """ Ensure that paused plans do not generate invoices. """ paused_plan = generator.subscribable_plan_version( edition=SoftwarePlanEdition.PAUSED) Subscription.new_domain_subscription( self.account, self.domain.name, paused_plan, date_start=self.invoice_start, date_end=self.invoice_end + datetime.timedelta(days=1), ) self.assertListEqual(self.invoice_factory._get_subscriptions(), [])
def test_should_not_invoice_paused_plan(self): """ Ensure that paused plans do not generate a CustomerInvoice """ paused_domain = generator.arbitrary_domain() self.addCleanup(paused_domain.delete) paused_plan = generator.subscribable_plan_version( edition=SoftwarePlanEdition.PAUSED) paused_plan.plan.is_customer_software_plan = True subscription = Subscription.new_domain_subscription( self.account, paused_domain.name, paused_plan, date_start=self.invoice_start, ) self.assertFalse( should_create_invoice(subscription=subscription, domain=subscription.subscriber.domain, invoice_start=self.invoice_start, invoice_end=self.invoice_end))
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()