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 setUp(self):
super(TestBillingAccount, 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.billing_account = generator.billing_account(
self.dimagi_user, self.billing_contact)
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_autopay_user(self):
self.assertFalse(self.billing_account.auto_pay_enabled)
mail.outbox = []
autopay_user = generator.arbitrary_web_user()
self.billing_account.update_autopay_user(autopay_user.username, None)
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(self.billing_account.auto_pay_enabled)
self.assertEqual(self.billing_account.auto_pay_user, autopay_user.username)
mail.outbox = []
other_autopay_user = generator.arbitrary_web_user()
self.billing_account.update_autopay_user(other_autopay_user.username, None)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(self.billing_account.auto_pay_user, other_autopay_user.username)
def setUp(self):
super(TestRenewSubscriptions, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.STANDARD)
today = datetime.date.today()
yesterday = today + datetime.timedelta(days=-1)
tomorrow = today + datetime.timedelta(days=1)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.standard_plan,
web_user=self.admin_user.username,
date_start=yesterday,
date_end=tomorrow,
)
self.subscription.save()
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_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 setUp(self):
super(TestRenewSubscriptions, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD)
today = datetime.date.today()
yesterday = today + datetime.timedelta(days=-1)
tomorrow = today + datetime.timedelta(days=1)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.standard_plan,
web_user=self.admin_user.username,
date_start=yesterday,
date_end=tomorrow,
)
self.subscription.save()
def setUp(self):
super(TestNewDomainSubscription, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.domain2 = Domain(
name="test-domain-sub2",
is_active=True,
)
self.domain2.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.account2 = BillingAccount.get_or_create_account_by_domain(
self.domain2.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.STANDARD)
self.advanced_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED)
def setUp(self):
super(TestStripePaymentMethod, self).setUp()
self.web_user = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.fake_card = FakeStripeCard()
self.fake_stripe_customer = FakeStripeCustomer(cards=[self.fake_card])
self.currency = generator.init_default_currency()
self.billing_account = generator.billing_account(self.dimagi_user, self.web_user)
self.billing_account_2 = generator.billing_account(self.dimagi_user, self.web_user)
self.payment_method = StripePaymentMethod(web_user=self.web_user.username,
customer_id=self.fake_stripe_customer.id)
self.payment_method.save()
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 test_autopay_user(self):
self.assertFalse(self.billing_account.auto_pay_enabled)
mail.outbox = []
autopay_user = generator.arbitrary_web_user()
self.billing_account.update_autopay_user(autopay_user.username, None)
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(self.billing_account.auto_pay_enabled)
self.assertEqual(self.billing_account.auto_pay_user,
autopay_user.username)
mail.outbox = []
other_autopay_user = generator.arbitrary_web_user()
self.billing_account.update_autopay_user(other_autopay_user.username,
None)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(self.billing_account.auto_pay_user,
other_autopay_user.username)
def setUp(self):
super(TestStripePaymentMethod, self).setUp()
self.web_user = generator.arbitrary_web_user()
self.dimagi_user = generator.arbitrary_web_user(is_dimagi=True)
self.fake_card = FakeStripeCard()
self.fake_stripe_customer = FakeStripeCustomer(cards=[self.fake_card])
self.currency = generator.init_default_currency()
self.billing_account = generator.billing_account(
self.dimagi_user, self.web_user)
self.billing_account_2 = generator.billing_account(
self.dimagi_user, self.web_user)
self.payment_method = StripePaymentMethod(
web_user=self.web_user.username,
customer_id=self.fake_stripe_customer.id)
self.payment_method.save()
def _generate_autopayable_entities(self):
"""
Create account, domain and subscription linked to the autopay user that have autopay enabled
"""
self.autopay_account = self.account
self.autopay_account.created_by_domain = self.domain
self.autopay_account.save()
self.autopay_user = generator.arbitrary_web_user()
self.fake_card = FakeStripeCard()
self.fake_stripe_customer = FakeStripeCustomer(cards=[self.fake_card])
self.autopay_account.update_autopay_user(self.autopay_user.username, self.domain)
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(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 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(TestCreditTransfers, self).setUp()
self.product_credit_amt = Decimal('500.00')
self.feature_credit_amt = Decimal('200.00')
self.subscription_credit_amt = Decimal('600.00')
self.domain = generator.arbitrary_domain()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain, created_by="*****@*****.**",
)[0]
self.web_user = generator.arbitrary_web_user()
# TODO - refactor interface to generator.billing_account so web user object is not required
self.other_account = generator.billing_account(self.web_user, self.web_user)
def _generate_autopayable_entities(self):
"""
Create account, domain and subscription linked to the autopay user that have autopay enabled
"""
self.autopay_account = self.account
self.autopay_account.created_by_domain = self.domain
self.autopay_account.save()
self.autopay_user = generator.arbitrary_web_user()
self.fake_card = FakeStripeCard()
self.fake_stripe_customer = FakeStripeCustomer(cards=[self.fake_card])
self.autopay_account.update_autopay_user(self.autopay_user.username,
self.domain)
def setUp(self):
super(TestUserRoleSubscriptionChanges, self).setUp()
self.domain = Domain(
name="test-sub-changes",
is_active=True,
)
self.domain.save()
UserRole.init_domain_with_presets(self.domain.name)
self.user_roles = UserRole.by_domain(self.domain.name)
self.custom_role = UserRole.get_or_create_with_permissions(
self.domain.name, Permissions(edit_apps=True, edit_web_users=True),
"Custom Role")
self.custom_role.save()
self.read_only_role = UserRole.get_read_only_role_by_domain(
self.domain.name)
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.web_users = []
self.commcare_users = []
for role in [self.custom_role] + self.user_roles:
web_user = generator.arbitrary_web_user()
web_user.add_domain_membership(self.domain.name,
role_id=role.get_id)
web_user.save()
self.web_users.append(web_user)
commcare_user = generator.arbitrary_commcare_user(
domain=self.domain.name)
commcare_user.set_role(self.domain.name, role.get_qualified_id())
commcare_user.save()
self.commcare_users.append(commcare_user)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED)
def setUp(self):
super(TestUserRoleSubscriptionChanges, self).setUp()
self.domain = Domain(
name="test-sub-changes",
is_active=True,
)
self.domain.save()
UserRole.init_domain_with_presets(self.domain.name)
self.user_roles = UserRole.by_domain(self.domain.name)
self.custom_role = UserRole.get_or_create_with_permissions(
self.domain.name,
Permissions(edit_apps=True, edit_web_users=True),
"Custom Role"
)
self.custom_role.save()
self.read_only_role = UserRole.get_read_only_role_by_domain(self.domain.name)
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.web_users = []
self.commcare_users = []
for role in [self.custom_role] + self.user_roles:
web_user = generator.arbitrary_web_user()
web_user.add_domain_membership(self.domain.name, role_id=role.get_id)
web_user.save()
self.web_users.append(web_user)
commcare_user = generator.arbitrary_commcare_user(
domain=self.domain.name)
commcare_user.set_role(self.domain.name, role.get_qualified_id())
commcare_user.save()
self.commcare_users.append(commcare_user)
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name,created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.ADVANCED)
def setUp(self):
super(TestCreditTransfers, self).setUp()
self.product_credit_amt = Decimal('500.00')
self.feature_credit_amt = Decimal('200.00')
self.subscription_credit_amt = Decimal('600.00')
self.domain = generator.arbitrary_domain()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain,
created_by="*****@*****.**",
)[0]
self.web_user = generator.arbitrary_web_user()
# TODO - refactor interface to generator.billing_account so web user object is not required
self.other_account = generator.billing_account(self.web_user,
self.web_user)
def setUp(self):
super(TestSubscriptionPermissionsChanges, self).setUp()
self.project = Domain(
name="test-sub-changes",
is_active=True,
)
self.project.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.project.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.project.name, created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.ADVANCED)
self._init_pro_with_rb_plan_and_version()
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(TestSubscriptionPermissionsChanges, self).setUp()
self.project = Domain(
name="test-sub-changes",
is_active=True,
)
self.project.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.project.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.project.name, created_by=self.admin_user.username)[0]
self.advanced_plan = DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.ADVANCED)
self._init_pro_with_rb_plan_and_version()
def test_set_autopay(self, fake_customer):
fake_customer.__get__ = mock.Mock(return_value=self.fake_stripe_customer)
self.assertEqual(self.billing_account.auto_pay_user, None)
self.assertFalse(self.billing_account.auto_pay_enabled)
self.payment_method.set_autopay(self.fake_card, self.billing_account, None)
self.assertEqual(self.fake_card.metadata, {"auto_pay_{}".format(self.billing_account.id): 'True'})
self.assertEqual(self.billing_account.auto_pay_user, self.web_user.username)
self.assertTrue(self.billing_account.auto_pay_enabled)
self.payment_method.set_autopay(self.fake_card, self.billing_account_2, None)
self.assertEqual(self.fake_card.metadata, {"auto_pay_{}".format(self.billing_account.id): 'True',
"auto_pay_{}".format(self.billing_account_2.id): 'True'})
other_web_user = generator.arbitrary_web_user()
other_payment_method = StripePaymentMethod(web_user=other_web_user.username)
different_fake_card = FakeStripeCard()
other_payment_method.set_autopay(different_fake_card, self.billing_account, None)
self.assertEqual(self.billing_account.auto_pay_user, other_web_user.username)
self.assertTrue(different_fake_card.metadata["auto_pay_{}".format(self.billing_account.id)])
self.assertFalse(self.fake_card.metadata["auto_pay_{}".format(self.billing_account.id)] == 'True')
def test_set_autopay(self, fake_customer):
fake_customer.__get__ = mock.Mock(
return_value=self.fake_stripe_customer)
self.assertEqual(self.billing_account.auto_pay_user, None)
self.assertFalse(self.billing_account.auto_pay_enabled)
self.payment_method.set_autopay(self.fake_card, self.billing_account,
None)
self.assertEqual(
self.fake_card.metadata,
{"auto_pay_{}".format(self.billing_account.id): 'True'})
self.assertEqual(self.billing_account.auto_pay_user,
self.web_user.username)
self.assertTrue(self.billing_account.auto_pay_enabled)
self.payment_method.set_autopay(self.fake_card, self.billing_account_2,
None)
self.assertEqual(
self.fake_card.metadata, {
"auto_pay_{}".format(self.billing_account.id): 'True',
"auto_pay_{}".format(self.billing_account_2.id): 'True'
})
other_web_user = generator.arbitrary_web_user()
other_payment_method = StripePaymentMethod(
web_user=other_web_user.username)
different_fake_card = FakeStripeCard()
other_payment_method.set_autopay(different_fake_card,
self.billing_account, None)
self.assertEqual(self.billing_account.auto_pay_user,
other_web_user.username)
self.assertTrue(different_fake_card.metadata["auto_pay_{}".format(
self.billing_account.id)])
self.assertFalse(self.fake_card.metadata["auto_pay_{}".format(
self.billing_account.id)] == 'True')
def setUp(self):
super(TestNewDomainSubscription, self).setUp()
self.domain = Domain(
name="test-domain-sub",
is_active=True,
)
self.domain.save()
self.domain2 = Domain(
name="test-domain-sub2",
is_active=True,
)
self.domain2.save()
self.admin_user = generator.arbitrary_web_user()
self.admin_user.add_domain_membership(self.domain.name, is_admin=True)
self.admin_user.save()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by=self.admin_user.username)[0]
self.account2 = BillingAccount.get_or_create_account_by_domain(
self.domain2.name, created_by=self.admin_user.username)[0]
self.standard_plan = DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.STANDARD)
self.advanced_plan = DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.ADVANCED)
def setUp(self):
super(TestBillingAccount, 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.billing_account = generator.billing_account(self.dimagi_user, self.billing_contact)
