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_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_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_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()
