def setUpClass(cls):
super().setUpClass()
cls.account = generator.get_billing_account_for_idp()
cls.domain = Domain.get_or_create_with_name("helping-earth-001",
is_active=True)
enterprise_plan = generator.get_enterprise_plan()
Subscription.new_domain_subscription(
account=cls.account,
domain=cls.domain.name,
plan_version=enterprise_plan,
)
cls.user = WebUser.create(cls.domain.name, '*****@*****.**',
'testpwd', None, None)
cls.idp = generator.create_idp('helping-earth', cls.account)
cls.idp.is_active = True
cls.idp.save()
AuthenticatedEmailDomain.objects.create(
email_domain='helpingearth.org',
identity_provider=cls.idp,
)
cls.domain_created_by_user = Domain.get_or_create_with_name(
"my-test-project", is_active=True)
cls.domain_created_by_user.creating_user = cls.user.username
cls.domain_created_by_user.save()
cls.external_domain = Domain.get_or_create_with_name("vaultwax-001",
is_active=True)
cls.user_without_idp = WebUser.create(cls.external_domain.name,
'*****@*****.**', 'testpwd',
None, None)
def test_new_susbscription_in_future(self):
"""
Test covers issue that came up with commcare-hq/PR#3725.
"""
today = datetime.date.today()
in_30_days = today + datetime.timedelta(days=30)
week_after_30 = in_30_days + datetime.timedelta(days=7)
next_year = week_after_30 + datetime.timedelta(days=400)
# mimic domain signing up for trial
trial_subscription = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
date_end=in_30_days,
adjustment_method=SubscriptionAdjustmentMethod.TRIAL,
is_trial=True,
)
trial_subscription.is_active = True
trial_subscription.save()
subscription = Subscription.new_domain_subscription(
self.account2, self.domain.name, self.standard_plan,
web_user=self.admin_user_name,
date_start=week_after_30, date_end=next_year,
)
final_sub = Subscription.visible_objects.get(pk=subscription.id)
self.assertEqual(final_sub.date_start, week_after_30)
self.assertEqual(final_sub.date_end, next_year)
def test_resubscription(self):
subscription = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user.username
)
self._change_std_roles()
subscription.cancel_subscription(web_user=self.admin_user.username)
custom_role = UserRole.get(self.custom_role.get_id)
self.assertTrue(custom_role.is_archived)
subscription = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user.username
)
custom_role = UserRole.get(self.custom_role.get_id)
self.assertFalse(custom_role.is_archived)
# disable this part of the test until we improve the UX for notifying
# downgraded users of their privilege changes
# custom_web_user = WebUser.get(self.web_users[0].get_id)
# custom_commcare_user = CommCareUser.get(self.commcare_users[0].get_id)
# self.assertEqual(
# custom_web_user.get_domain_membership(self.domain.name).role_id,
# self.read_only_role.get_id
# )
# self.assertIsNone(
# custom_commcare_user.get_domain_membership(self.domain.name).role_id
# )
self.assertInitialRoles()
self.assertStdUsers()
subscription.cancel_subscription(web_user=self.admin_user.username)
def test_exceeding_max_domains_prevents_new_domains(self):
self.advanced_plan.plan.max_domains = 1
Subscription.new_domain_subscription(self.account, self.domain.name,
self.advanced_plan)
self.assertRaises(
NewSubscriptionError, lambda: Subscription.new_domain_subscription(
self.account, self.domain2.name, self.advanced_plan))
def test_resubscription(self):
subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.advanced_plan,
web_user=self.admin_user.username)
self._change_std_roles()
subscription.cancel_subscription(web_user=self.admin_user.username)
custom_role = UserRole.get(self.custom_role.get_id)
self.assertTrue(custom_role.is_archived)
subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.advanced_plan,
web_user=self.admin_user.username)
custom_role = UserRole.get(self.custom_role.get_id)
self.assertFalse(custom_role.is_archived)
# disable this part of the test until we improve the UX for notifying
# downgraded users of their privilege changes
# custom_web_user = WebUser.get(self.web_users[0].get_id)
# custom_commcare_user = CommCareUser.get(self.commcare_users[0].get_id)
# self.assertEqual(
# custom_web_user.get_domain_membership(self.domain.name).role_id,
# self.read_only_role.get_id
# )
# self.assertIsNone(
# custom_commcare_user.get_domain_membership(self.domain.name).role_id
# )
self._assertInitialRoles()
self._assertStdUsers()
subscription.cancel_subscription(web_user=self.admin_user.username)
def test_preexisting_past_subscription(self):
past_subscription_end_date = self.from_date - timedelta(days=10)
past_subscription_start_date = past_subscription_end_date - timedelta(days=5)
plan_version = self._random_plan_version
Subscription.new_domain_subscription(
self._preexisting_subscription_account,
self.domain.name,
plan_version,
date_start=past_subscription_start_date,
date_end=past_subscription_end_date,
)
self._assign_community_subscriptions()
self.assertEqual(Subscription.objects.count(), 2)
self.assertFalse(Subscription.objects.exclude(subscriber__domain=self.domain.name).exists())
self.assertIsNotNone(Subscription.objects.get(
date_start=self.from_date,
date_end=None,
plan_version=self._most_recently_created_community_plan_version,
skip_invoicing_if_no_feature_charges=True,
))
self.assertIsNotNone(Subscription.objects.get(
date_start=past_subscription_start_date,
date_end=past_subscription_end_date,
plan_version=plan_version,
))
def test_preexisting_past_subscription(self):
past_subscription_end_date = self.from_date - timedelta(days=10)
past_subscription_start_date = past_subscription_end_date - timedelta(days=5)
plan_version = self._random_plan_version
Subscription.new_domain_subscription(
self._preexisting_subscription_account,
self.domain.name,
plan_version,
date_start=past_subscription_start_date,
date_end=past_subscription_end_date,
)
self._assign_community_subscriptions()
self.assertEqual(Subscription.objects.count(), 2)
self.assertFalse(Subscription.objects.exclude(subscriber__domain=self.domain.name).exists())
self.assertIsNotNone(Subscription.objects.get(
date_start=self.from_date,
date_end=None,
plan_version=self._most_recently_created_community_plan_version,
skip_invoicing_if_no_feature_charges=True,
))
self.assertIsNotNone(Subscription.objects.get(
date_start=past_subscription_start_date,
date_end=past_subscription_end_date,
plan_version=plan_version,
))
def setUpClass(cls):
super().setUpClass()
billing_contact = accounting_generator.create_arbitrary_web_user_name()
dimagi_user = accounting_generator.create_arbitrary_web_user_name(is_dimagi=True)
plan = DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.ADVANCED)
account_no_hubspot = accounting_generator.billing_account(
dimagi_user, billing_contact
)
account_no_hubspot.block_hubspot_data_for_all_users = True
account_no_hubspot.save()
cls.domain_no_hubspot = Domain.get_or_create_with_name(
"domain-no-hubspot-001",
is_active=True
)
cls.subscription_no_hubspot = Subscription.new_domain_subscription(
account=account_no_hubspot,
domain=cls.domain_no_hubspot.name,
plan_version=plan,
)
regular_account = accounting_generator.billing_account(
dimagi_user, billing_contact
)
cls.regular_domain = Domain.get_or_create_with_name(
"domain-with-analytics-001",
is_active=True
)
cls.regular_subscription = Subscription.new_domain_subscription(
account=regular_account,
domain=cls.regular_domain.name,
plan_version=plan,
)
def test_new_susbscription_in_future(self):
"""
Test covers issue that came up with commcare-hq/PR#3725.
"""
today = datetime.date.today()
in_30_days = today + datetime.timedelta(days=30)
week_after_30 = in_30_days + datetime.timedelta(days=7)
next_year = week_after_30 + datetime.timedelta(days=400)
# mimic domain signing up for trial
trial_subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.advanced_plan,
date_end=in_30_days,
adjustment_method=SubscriptionAdjustmentMethod.TRIAL,
is_trial=True,
)
trial_subscription.is_active = True
trial_subscription.save()
subscription = Subscription.new_domain_subscription(
self.account2,
self.domain.name,
self.standard_plan,
web_user=self.admin_user_name,
date_start=week_after_30,
date_end=next_year,
)
final_sub = Subscription.visible_objects.get(pk=subscription.id)
self.assertEqual(final_sub.date_start, week_after_30)
self.assertEqual(final_sub.date_end, next_year)
def test_exceeding_max_domains_prevents_new_domains(self):
self.advanced_plan.plan.max_domains = 1
Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan
)
self.assertRaises(NewSubscriptionError, lambda: Subscription.new_domain_subscription(
self.account, self.domain2.name, self.advanced_plan
))
def test_change_plan_blocks_on_max_domains(self):
Subscription.new_domain_subscription(self.account, self.domain.name,
self.advanced_plan)
sub2 = Subscription.new_domain_subscription(self.account,
self.domain2.name,
self.community_plan)
self.assertRaises(SubscriptionAdjustmentError,
lambda: sub2.change_plan(self.advanced_plan))
def test_change_plan_blocks_on_max_domains(self):
Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan
)
sub2 = Subscription.new_domain_subscription(
self.account, self.domain2.name, self.community_plan
)
self.assertRaises(SubscriptionAdjustmentError, lambda: sub2.change_plan(self.advanced_plan))
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_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_transfers(self):
advanced_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED
)
standard_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD
)
first_sub = Subscription.new_domain_subscription(
self.account, self.domain.name, advanced_plan,
date_start=datetime.date.today() - relativedelta(days=1),
)
product_credit = CreditLine.add_credit(
self.product_credit_amt, subscription=first_sub,
is_product=True,
)
feature_credit = CreditLine.add_credit(
self.feature_credit_amt, subscription=first_sub,
feature_type=FeatureType.USER,
)
subscription_credit = CreditLine.add_credit(
self.subscription_credit_amt, subscription=first_sub,
)
original_credits = [
product_credit, feature_credit, subscription_credit,
]
second_sub = first_sub.change_plan(standard_plan)
second_credits = self._ensure_transfer(original_credits)
for credit_line in second_credits:
self.assertEqual(credit_line.subscription.pk, second_sub.pk)
second_sub.date_end = datetime.date.today() + datetime.timedelta(days=5)
second_sub.save()
third_sub = second_sub.renew_subscription()
deactivate_subscriptions(second_sub.date_end)
third_sub = Subscription.visible_objects.get(id=third_sub.id)
third_credits = self._ensure_transfer(second_credits)
for credit_line in third_credits:
self.assertEqual(credit_line.subscription.pk, third_sub.pk)
third_sub.date_end = third_sub.date_start + relativedelta(days=1)
third_sub.save()
Subscription.new_domain_subscription(
self.other_account, self.domain, DefaultProductPlan.get_default_plan_version(),
date_start=third_sub.date_end,
)
deactivate_subscriptions(third_sub.date_end)
account_credits = self._ensure_transfer(third_credits)
for credit_line in account_credits:
self.assertIsNone(credit_line.subscription)
self.assertEqual(credit_line.account.pk, self.account.pk)
def test_transfers(self):
advanced_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED
)
standard_plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD
)
first_sub = Subscription.new_domain_subscription(
self.account, self.domain.name, advanced_plan,
date_start=datetime.date.today() - relativedelta(days=1),
)
product_credit = CreditLine.add_credit(
self.product_credit_amt, subscription=first_sub,
is_product=True,
)
feature_credit = CreditLine.add_credit(
self.feature_credit_amt, subscription=first_sub,
feature_type=FeatureType.USER,
)
subscription_credit = CreditLine.add_credit(
self.subscription_credit_amt, subscription=first_sub,
)
original_credits = [
product_credit, feature_credit, subscription_credit,
]
second_sub = first_sub.change_plan(standard_plan)
second_credits = self._ensure_transfer(original_credits)
for credit_line in second_credits:
self.assertEqual(credit_line.subscription.pk, second_sub.pk)
second_sub.date_end = datetime.date.today() + datetime.timedelta(days=5)
second_sub.save()
third_sub = second_sub.renew_subscription()
deactivate_subscriptions(second_sub.date_end)
third_sub = Subscription.visible_objects.get(id=third_sub.id)
third_credits = self._ensure_transfer(second_credits)
for credit_line in third_credits:
self.assertEqual(credit_line.subscription.pk, third_sub.pk)
third_sub.date_end = third_sub.date_start + relativedelta(days=1)
third_sub.save()
Subscription.new_domain_subscription(
self.other_account, self.domain, DefaultProductPlan.get_default_plan_version(),
date_start=third_sub.date_end,
)
deactivate_subscriptions(third_sub.date_end)
account_credits = self._ensure_transfer(third_credits)
for credit_line in account_credits:
self.assertIsNone(credit_line.subscription)
self.assertEqual(credit_line.account.pk, self.account.pk)
def make_new_enterprise_subscription(self, domain):
account, _ = BillingAccount.get_or_create_account_by_domain(
domain.name,
account_type=BillingAccountType.CONTRACT,
created_by="management command",
)
Subscription.new_domain_subscription(
account,
domain.name,
self.enterprise_plan_version,
)
def make_new_enterprise_subscription(self, domain):
account, _ = BillingAccount.get_or_create_account_by_domain(
domain.name,
account_type=BillingAccountType.CONTRACT,
created_by="management command",
)
Subscription.new_domain_subscription(
account,
domain.name,
self.enterprise_plan_version,
)
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 setUpClass(cls):
super().setUpClass()
cls.project = create_domain(DOMAIN_NAME)
account, __ = BillingAccount.get_or_create_account_by_domain(
DOMAIN_NAME, created_by=ADMIN_USER)
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
Subscription.new_domain_subscription(
account,
DOMAIN_NAME,
plan,
web_user=ADMIN_USER,
)
def test_app_icon_permissions(self):
LOGO_HOME = u'hq_logo_android_home'
LOGO_LOGIN = u'hq_logo_android_login'
advanced_sub = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user.username
)
with open(os.path.join(os.path.dirname(__file__), 'data', 'app-commcare-icon-standard.json')) as f:
standard_source = json.load(f)
with open(os.path.join(os.path.dirname(__file__), 'data', 'app-commcare-icon-build.json')) as f:
build_source = json.load(f)
app_standard = Application.wrap(standard_source)
app_standard.save()
self.assertEqual(self.domain.name, app_standard.domain)
app_build = Application.wrap(build_source)
app_build.save()
self.assertEqual(self.domain.name, app_build.domain)
self.assertTrue(LOGO_HOME in app_standard.logo_refs.keys())
self.assertTrue(LOGO_LOGIN in app_standard.logo_refs.keys())
self.assertTrue(LOGO_HOME in app_build.logo_refs.keys())
self.assertTrue(LOGO_LOGIN in app_build.logo_refs.keys())
advanced_sub.cancel_subscription(web_user=self.admin_user.username)
app_standard = Application.get(app_standard._id)
app_build = Application.get(app_build._id)
self.assertFalse(LOGO_HOME in app_standard.logo_refs.keys())
self.assertFalse(LOGO_LOGIN in app_standard.logo_refs.keys())
self.assertFalse(LOGO_HOME in app_build.logo_refs.keys())
self.assertFalse(LOGO_LOGIN in app_build.logo_refs.keys())
Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user.username
)
app_standard = Application.get(app_standard._id)
app_build = Application.get(app_build._id)
self.assertTrue(LOGO_HOME in app_standard.logo_refs.keys())
self.assertTrue(LOGO_LOGIN in app_standard.logo_refs.keys())
self.assertTrue(LOGO_HOME in app_build.logo_refs.keys())
self.assertTrue(LOGO_LOGIN in app_build.logo_refs.keys())
def assign_explicit_community_subscription(domain_name, start_date, method, account=None, web_user=None):
future_subscriptions = Subscription.visible_objects.filter(
date_start__gt=start_date,
subscriber__domain=domain_name,
)
if future_subscriptions.exists():
end_date = future_subscriptions.earliest('date_start').date_start
else:
end_date = None
if account is None:
account = BillingAccount.get_or_create_account_by_domain(
domain_name,
created_by='assign_explicit_community_subscriptions',
entry_point=EntryPoint.SELF_STARTED,
)[0]
return Subscription.new_domain_subscription(
account=account,
domain=domain_name,
plan_version=DefaultProductPlan.get_default_plan_version(),
date_start=start_date,
date_end=end_date,
skip_invoicing_if_no_feature_charges=True,
adjustment_method=method,
internal_change=True,
service_type=SubscriptionType.PRODUCT,
web_user=web_user,
)
def setUpClass(cls):
super(APIResourceTest, cls).setUpClass()
Role.get_cache().clear()
cls.domain = Domain.get_or_create_with_name('qwerty', is_active=True)
cls.list_endpoint = cls._get_list_endpoint()
cls.username = '******'
cls.password = '******'
cls.user = WebUser.create(cls.domain.name,
cls.username,
cls.password,
None,
None,
email='*****@*****.**',
first_name='rudolph',
last_name='commcare')
cls.user.set_role(cls.domain.name, 'admin')
cls.user.save()
cls.account = BillingAccount.get_or_create_account_by_domain(
cls.domain.name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
cls.subscription = Subscription.new_domain_subscription(
cls.account, cls.domain.name, plan)
cls.subscription.is_active = True
cls.subscription.save()
cls.api_key, _ = HQApiKey.objects.get_or_create(
user=WebUser.get_django_user(cls.user))
def setUp(self):
super(OptTestCase, self).setUp()
self.domain = "opt-test"
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
generator.instantiate_accounting_for_tests()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain_obj.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain_obj, edition=SoftwarePlanEdition.ADVANCED)
self.subscription = Subscription.new_domain_subscription(
self.account, self.domain_obj.name, plan)
self.subscription.is_active = True
self.subscription.save()
self.backend = TestSMSBackend(is_global=True)
self.backend.save()
self.backend_mapping = BackendMapping(
is_global=True,
prefix="*",
backend_id=self.backend._id,
)
self.backend_mapping.save()
def create_30_day_trial(domain_obj):
from corehq.apps.accounting.models import (
DefaultProductPlan,
SoftwarePlanEdition,
BillingAccount,
Currency,
BillingAccountType,
Subscription,
SubscriptionAdjustmentMethod,
)
# Create a 30 Day Trial subscription to the Advanced Plan
advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain(
domain_obj, edition=SoftwarePlanEdition.ADVANCED, is_trial=True)
expiration_date = date.today() + timedelta(days=30)
trial_account = BillingAccount.objects.get_or_create(
name="Trial Account for %s" % domain_obj.name,
currency=Currency.get_default(),
created_by_domain=domain_obj.name,
account_type=BillingAccountType.TRIAL,
)[0]
trial_subscription = Subscription.new_domain_subscription(
trial_account,
domain_obj.name,
advanced_plan_version,
date_end=expiration_date,
adjustment_method=SubscriptionAdjustmentMethod.TRIAL,
is_trial=True,
)
trial_subscription.is_active = True
trial_subscription.save()
def test_update_billing_account_entry_point_contracted(self):
contracted_subscription = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user_name, service_type=SubscriptionType.IMPLEMENTATION
)
self.assertNotEqual(contracted_subscription.account.entry_point, EntryPoint.SELF_STARTED)
def handle(self, *args, **options):
if len(args) != 1:
print "Invalid arguments: %s" % str(args)
return
domain = Domain.get_by_name(args[0])
if not domain:
print "Invalid domain name: %s" % args[0]
return
account, _ = BillingAccount.get_or_create_account_by_domain(
domain.name,
account_type=BillingAccountType.CONTRACT,
created_by="management command",
)
enterprise_plan_version = SoftwarePlanVersion.objects.filter(
plan__edition=SoftwarePlanEdition.ENTERPRISE
)[0]
try:
subscription = Subscription.new_domain_subscription(
account,
domain.name,
enterprise_plan_version
)
except NewSubscriptionError as e:
print e.message
return
subscription.is_active = True
subscription.save()
print 'Domain %s has been upgraded to enterprise level.' % domain.name
def assign_explicit_community_subscription(domain_name, start_date):
future_subscriptions = Subscription.objects.filter(
CONSISTENT_DATES_CHECK
).filter(
date_start__gt=start_date,
subscriber__domain=domain_name,
)
if future_subscriptions.exists():
end_date = future_subscriptions.latest('date_start').date_start
else:
end_date = None
return Subscription.new_domain_subscription(
account=BillingAccount.get_or_create_account_by_domain(
domain_name,
created_by='assign_explicit_community_subscriptions',
entry_point=EntryPoint.SELF_STARTED,
)[0],
domain=domain_name,
plan_version=DefaultProductPlan.get_default_plan_version(),
date_start=start_date,
date_end=end_date,
skip_invoicing_if_no_feature_charges=True,
adjustment_method=SubscriptionAdjustmentMethod.TASK,
internal_change=True,
service_type=SubscriptionType.PRODUCT,
)
def test_update_billing_account_entry_point_contracted(self):
contracted_subscription = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user_name, service_type=SubscriptionType.IMPLEMENTATION
)
self.assertNotEqual(contracted_subscription.account.entry_point, EntryPoint.SELF_STARTED)
def test_customer_plan_not_added_to_regular_account(self):
subscription = Subscription.new_domain_subscription(
domain=self.domain.name,
plan_version=self.customer_plan,
account=self.customer_account
)
subscription_form = SubscriptionForm(
subscription=subscription,
account_id=self.customer_plan.id,
web_user=self.web_user,
)
subscription_form.cleaned_data = {
'active_accounts': self.account.id,
'start_date': datetime.date.today(),
'end_date': None,
'do_not_invoice': None,
'no_invoice_reason': None,
'do_not_email_invoice': None,
'do_not_email_reminder': None,
'auto_generate_credits': None,
'skip_invoicing_if_no_feature_charges': None,
'salesforce_contract_id': None,
'service_type': None,
'pro_bono_status': None,
'funding_source': None,
'skip_auto_downgrade': None,
'skip_auto_downgrade_reason': None
}
self.assertRaises(ValidationError, lambda: subscription_form.clean_active_accounts())
def setUp(self):
super(TestDeleteDomain, self).setUp()
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.current_subscription = Subscription.new_domain_subscription(
BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by='tests')[0],
self.domain.name,
DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.ADVANCED),
date_start=date.today() - relativedelta(days=1),
)
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
def test_cache_cleanup_when_domain_subscription_changes(self):
"""
Ensure that the cache for IdentityProvider.does_domain_trust_this_idp
is cleared when the status of a domain's subscription changes.
"""
domain = Domain.get_or_create_with_name("vaultwax-001", is_active=True)
self.addCleanup(lambda: domain.delete())
enterprise_plan = generator.get_enterprise_plan()
self.assertFalse(self.idp.does_domain_trust_this_idp(domain.name))
sub = Subscription.new_domain_subscription(
self.idp.owner,
domain.name,
enterprise_plan,
)
self.assertTrue(self.idp.does_domain_trust_this_idp(domain.name))
sub.is_active = False
sub.save()
self.assertFalse(self.idp.does_domain_trust_this_idp(domain.name))
sub.is_active = True
sub.save()
self.assertTrue(self.idp.does_domain_trust_this_idp(domain.name))
SubscriptionAdjustment.objects.all().delete()
Subscription.visible_and_suppressed_objects.all().delete()
self.assertFalse(self.idp.does_domain_trust_this_idp(domain.name))
def setUp(self):
super(OptTestCase, self).setUp()
self.domain = "opt-test"
self.domain_obj = Domain(name=self.domain)
self.domain_obj.save()
generator.instantiate_accounting_for_tests()
self.account = BillingAccount.get_or_create_account_by_domain(
self.domain_obj.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
self.domain_obj, edition=SoftwarePlanEdition.ADVANCED
)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain_obj.name,
plan
)
self.subscription.is_active = True
self.subscription.save()
self.backend = TestSMSBackend(is_global=True)
self.backend.save()
self.backend_mapping = BackendMapping(
is_global=True,
prefix="*",
backend_id=self.backend._id,
)
self.backend_mapping.save()
def _setup_accounting(cls):
cls.account, _ = BillingAccount.get_or_create_account_by_domain(
cls.domain.name, created_by='')
plan_version = DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.STANDARD)
cls.subscription = Subscription.new_domain_subscription(
cls.account, cls.domain.name, plan_version)
def setUp(self):
super(BaseReminderTestCase, self).setUp()
self.domain_obj = Domain(name="test")
self.domain_obj.save()
# Prevent resource conflict
self.domain_obj = Domain.get(self.domain_obj._id)
self.account, _ = BillingAccount.get_or_create_account_by_domain(
self.domain_obj.name,
created_by="tests"
)
advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain(
self.domain_obj, edition=SoftwarePlanEdition.ADVANCED)
self.subscription = Subscription.new_domain_subscription(
self.account,
self.domain_obj.name,
advanced_plan_version
)
self.subscription.is_active = True
self.subscription.save()
self.sms_backend = TestSMSBackend(named="MOBILE_BACKEND_TEST", is_global=True)
self.sms_backend.save()
self.sms_backend_mapping = BackendMapping(is_global=True,prefix="*",backend_id=self.sms_backend._id)
self.sms_backend_mapping.save()
def assign_explicit_community_subscription(domain_name, start_date):
future_subscriptions = Subscription.objects.filter(
CONSISTENT_DATES_CHECK).filter(
date_start__gt=start_date,
subscriber__domain=domain_name,
)
if future_subscriptions.exists():
end_date = future_subscriptions.latest('date_start').date_start
else:
end_date = None
return Subscription.new_domain_subscription(
account=BillingAccount.get_or_create_account_by_domain(
domain_name,
created_by='assign_explicit_community_subscriptions',
entry_point=EntryPoint.SELF_STARTED,
)[0],
domain=domain_name,
plan_version=DefaultProductPlan.get_default_plan_version(),
date_start=start_date,
date_end=end_date,
skip_invoicing_if_no_feature_charges=True,
adjustment_method=SubscriptionAdjustmentMethod.TASK,
internal_change=True,
service_type=SubscriptionType.PRODUCT,
)
def create_30_day_trial(domain_obj):
from corehq.apps.accounting.models import (
DefaultProductPlan,
SoftwarePlanEdition,
BillingAccount,
Currency,
BillingAccountType,
Subscription,
SubscriptionAdjustmentMethod,
)
# Create a 30 Day Trial subscription to the Advanced Plan
advanced_plan_version = DefaultProductPlan.get_default_plan_by_domain(
domain_obj, edition=SoftwarePlanEdition.ADVANCED, is_trial=True
)
expiration_date = date.today() + timedelta(days=30)
trial_account = BillingAccount.objects.get_or_create(
name="Trial Account for %s" % domain_obj.name,
currency=Currency.get_default(),
created_by_domain=domain_obj.name,
account_type=BillingAccountType.TRIAL,
)[0]
trial_subscription = Subscription.new_domain_subscription(
trial_account, domain_obj.name, advanced_plan_version,
date_end=expiration_date,
adjustment_method=SubscriptionAdjustmentMethod.TRIAL,
is_trial=True,
)
trial_subscription.is_active = True
trial_subscription.save()
def setUp(self):
super(TestDeleteDomain, self).setUp()
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.current_subscription = Subscription.new_domain_subscription(
BillingAccount.get_or_create_account_by_domain(self.domain.name, created_by='tests')[0],
self.domain.name,
DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.ADVANCED),
date_start=date.today() - relativedelta(days=1),
)
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
def assign_explicit_community_subscription(domain_name, start_date, method, account=None, web_user=None):
future_subscriptions = Subscription.visible_objects.filter(
date_start__gt=start_date,
subscriber__domain=domain_name,
)
if future_subscriptions.exists():
end_date = future_subscriptions.earliest('date_start').date_start
else:
end_date = None
if account is None:
account = BillingAccount.get_or_create_account_by_domain(
domain_name,
created_by='assign_explicit_community_subscriptions',
entry_point=EntryPoint.SELF_STARTED,
)[0]
return Subscription.new_domain_subscription(
account=account,
domain=domain_name,
plan_version=DefaultProductPlan.get_default_plan_version(),
date_start=start_date,
date_end=end_date,
skip_invoicing_if_no_feature_charges=True,
adjustment_method=method,
internal_change=True,
service_type=SubscriptionType.PRODUCT,
web_user=web_user,
)
def prepare_domain(domain_name):
from corehq.apps.commtrack.tests import bootstrap_domain
domain = bootstrap_domain(domain_name)
previous = None
for name, administrative in [("MOHSW", True), ("MSDZONE", True),
("REGION", True), ("DISTRICT", True),
("FACILITY", False)]:
previous, _ = LocationType.objects.get_or_create(
domain=domain_name,
name=name,
parent_type=previous,
administrative=administrative,
)
generator.instantiate_accounting_for_tests()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
domain, edition=SoftwarePlanEdition.ADVANCED)
commtrack = domain.commtrack_settings
commtrack.actions.append(
CommtrackActionConfig(action='receipts',
keyword='delivered',
caption='Delivered'))
commtrack.save()
subscription = Subscription.new_domain_subscription(
account, domain.name, plan)
subscription.is_active = True
subscription.save()
ils_config = ILSGatewayConfig(enabled=True, domain=domain.name)
ils_config.save()
return domain
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_by_domain(
self.domain.name, 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 create_domain(self, domain):
domain_obj = Domain(name=domain)
domain_obj.use_default_sms_response = True
domain_obj.default_sms_response = "Default SMS Response"
domain_obj.save()
# I tried making this class inherit from BaseSMSTest, but somehow
# the multiple inheritance was causing the postgres connection to
# get in a weird state where it wasn't commiting any changes. So
# for now, keeping this subscription setup code as is.
generator.instantiate_accounting_for_tests()
self.account = BillingAccount.get_or_create_account_by_domain(
domain_obj.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan_by_domain(
domain_obj, edition=SoftwarePlanEdition.ADVANCED
)
self.subscription = Subscription.new_domain_subscription(
self.account,
domain_obj.name,
plan
)
self.subscription.is_active = True
self.subscription.save()
return domain_obj
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 save(self, commit=True):
account_save_success = super(ConfirmNewSubscriptionForm, self).save(commit=False)
if not account_save_success:
return False
try:
if self.current_subscription is not None:
if self.plan_version.plan.edition == SoftwarePlanEdition.COMMUNITY:
self.current_subscription.cancel_subscription(adjustment_method=SubscriptionAdjustmentMethod.USER,
web_user=self.creating_user)
else:
subscription = self.current_subscription.change_plan(
self.plan_version, web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER
)
subscription.is_active = True
subscription.save()
else:
subscription = Subscription.new_domain_subscription(
self.account, self.domain, self.plan_version,
web_user=self.creating_user,
adjustment_method=SubscriptionAdjustmentMethod.USER)
subscription.is_active = True
if subscription.plan_version.plan.edition == SoftwarePlanEdition.ENTERPRISE:
# this point can only be reached if the initiating user was a superuser
subscription.do_not_invoice = True
subscription.save()
return True
except Exception:
logger.exception("There was an error subscribing the domain '%s' to plan '%s'. "
"Go quickly!" % (self.domain, self.plan_version.plan.name))
return False
def setUpClass(cls):
super(TestZapierIntegration, cls).setUpClass()
generator.instantiate_accounting()
cls.domain_object = Domain.get_or_create_with_name(TEST_DOMAIN,
is_active=True)
cls.domain = cls.domain_object.name
account = BillingAccount.get_or_create_account_by_domain(
cls.domain, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.STANDARD)
subscription = Subscription.new_domain_subscription(
account, cls.domain, plan)
subscription.is_active = True
subscription.save()
cls.web_user = WebUser.create(cls.domain, 'test', '******')
api_key_object, _ = ApiKey.objects.get_or_create(
user=cls.web_user.get_django_user())
cls.api_key = api_key_object.key
cls.application = Application.new_app(cls.domain, 'Test App')
cls.application.save()
module = cls.application.add_module(Module.new_module(
"Module 1", "en"))
cls.application.new_form(module.id,
name="Form1",
attachment=XFORM,
lang="en")
cls.application.save()
def test_transfers(self):
advanced_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain, edition=SoftwarePlanEdition.ADVANCED)
standard_plan = DefaultProductPlan.get_default_plan_by_domain(self.domain, edition=SoftwarePlanEdition.STANDARD)
first_sub = Subscription.new_domain_subscription(self.account, self.domain, advanced_plan)
product_credit = CreditLine.add_credit(
self.product_credit_amt, subscription=first_sub, product_type=SoftwareProductType.COMMCARE
)
feature_credit = CreditLine.add_credit(
self.feature_credit_amt, subscription=first_sub, feature_type=FeatureType.USER
)
subscription_credit = CreditLine.add_credit(self.subscription_credit_amt, subscription=first_sub)
original_credits = [product_credit, feature_credit, subscription_credit]
second_sub = first_sub.change_plan(standard_plan)
second_credits = self._ensure_transfer(original_credits)
for credit_line in second_credits:
self.assertEqual(credit_line.subscription.pk, second_sub.pk)
second_sub.date_end = datetime.date.today() + datetime.timedelta(days=5)
second_sub.save()
third_sub = second_sub.renew_subscription()
third_credits = self._ensure_transfer(second_credits)
for credit_line in third_credits:
self.assertEqual(credit_line.subscription.pk, third_sub.pk)
third_sub.cancel_subscription()
account_credits = self._ensure_transfer(third_credits)
for credit_line in account_credits:
self.assertIsNone(credit_line.subscription)
self.assertEqual(credit_line.account.pk, self.account.pk)
def test_customer_plan_not_added_to_regular_account(self):
subscription = Subscription.new_domain_subscription(
domain=self.domain.name,
plan_version=self.customer_plan,
account=self.customer_account
)
subscription_form = SubscriptionForm(
subscription=subscription,
account_id=self.customer_plan.id,
web_user=self.web_user,
)
subscription_form.cleaned_data = {
'active_accounts': self.account.id,
'start_date': datetime.date.today(),
'end_date': None,
'do_not_invoice': None,
'no_invoice_reason': None,
'do_not_email_invoice': None,
'do_not_email_reminder': None,
'auto_generate_credits': None,
'skip_invoicing_if_no_feature_charges': None,
'salesforce_contract_id': None,
'service_type': None,
'pro_bono_status': None,
'funding_source': None,
'skip_auto_downgrade': None,
'skip_auto_downgrade_reason': None
}
self.assertRaises(ValidationError, lambda: subscription_form.clean_active_accounts())
def test_wrong_domain(self):
'''
If correct credentials for a user in a different domain are submitted, the response is forbidden
'''
wrong_domain = Domain.get_or_create_with_name('dvorak', is_active=True)
self.addCleanup(wrong_domain.delete)
# have to set up subscription for the bad domain or it will fail on authorization
new_account = BillingAccount.get_or_create_account_by_domain(
wrong_domain.name, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.ADVANCED)
new_subscription = Subscription.new_domain_subscription(
new_account, wrong_domain.name, plan)
new_subscription.is_active = True
new_subscription.save()
wrong_list_endpoint = reverse(
'api_dispatch_list',
kwargs=dict(domain=wrong_domain.name,
api_name=self.api_name,
resource_name=self.resource.Meta.resource_name))
response = self.client.post(wrong_list_endpoint, {
'username': self.username,
'password': self.password
})
self.assertEqual(response.status_code, 403)
def save(self, commit=True):
try:
billing_contact_info = super(BillingAccountInfoForm, self).save(commit=False)
billing_contact_info.account = self.account
billing_contact_info.save()
billing_admins = self.cleaned_data['billing_admins']
for admin in billing_admins:
if not self.account.billing_admins.filter(web_user=admin.web_user).exists():
self.account.billing_admins.add(admin)
self.account.save()
if self.current_subscription is not None:
if self.plan_version.plan.edition == SoftwarePlanEdition.COMMUNITY:
self.current_subscription.cancel_subscription(adjustment_method=SubscriptionAdjustmentMethod.USER,
web_user=self.creating_user)
else:
subscription = self.current_subscription.change_plan(
self.plan_version, web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER
)
subscription.is_active = True
subscription.save()
else:
subscription = Subscription.new_domain_subscription(
self.account, self.domain, self.plan_version,
web_user=self.creating_user, adjustment_method=SubscriptionAdjustmentMethod.USER
)
subscription.is_active = True
subscription.save()
return True
except Exception:
logger.exception("There was an error subscribing the domain '%s' to plan '%s'. "
"Go quickly!" % (self.domain, self.plan_version.plan.name))
return False
def _setup_accounting(cls):
call_command('cchq_prbac_bootstrap')
cls.account, _ = BillingAccount.get_or_create_account_by_domain(
cls.domain.name, created_by='')
plan_version = DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.ADVANCED)
cls.subscription = Subscription.new_domain_subscription(
cls.account, cls.domain.name, plan_version)
def test_new_subscription_without_end_date_is_included(self):
new_subscription = Subscription.new_domain_subscription(
account=self.customer_account,
domain=self.domain.name,
plan_version=self.customer_plan_version,
date_start=date(2019, 5, 31),
)
line_item_factory = LineItemFactory(new_subscription, None, self.mock_customer_invoice)
self.assertEqual(line_item_factory.subscribed_domains, [self.domain.name])
def test_update_billing_account_entry_point_self_serve(self):
self_serve_subscription = Subscription.new_domain_subscription(
self.account,
self.domain.name,
self.advanced_plan,
web_user=self.admin_user_name,
service_type=SubscriptionType.PRODUCT)
self.assertEqual(self_serve_subscription.account.entry_point,
EntryPoint.SELF_STARTED)
def test_dont_update_billing_account_if_set(self):
self.account.entry_point = EntryPoint.CONTRACTED
self.account.save()
subscription = Subscription.new_domain_subscription(
self.account, self.domain.name, self.advanced_plan,
web_user=self.admin_user_name, service_type=SubscriptionType.IMPLEMENTATION
)
self.assertEqual(subscription.account.entry_point, EntryPoint.CONTRACTED)
def setup_subscription(cls, domain_name, software_plan):
generator.instantiate_accounting()
plan = DefaultProductPlan.get_default_plan_version(edition=software_plan)
cls.account = BillingAccount.get_or_create_account_by_domain(
domain_name, created_by="automated-test" + cls.__name__
)[0]
cls.subscription = Subscription.new_domain_subscription(cls.account, domain_name, plan)
cls.subscription.is_active = True
cls.subscription.save()
def setup_subscription(cls, domain_name, software_plan):
generator.instantiate_accounting()
plan = DefaultProductPlan.get_default_plan_version(edition=software_plan)
cls.account = BillingAccount.get_or_create_account_by_domain(
domain_name, created_by="automated-test" + cls.__name__
)[0]
cls.subscription = Subscription.new_domain_subscription(cls.account, domain_name, plan)
cls.subscription.is_active = True
cls.subscription.save()
def setUpClass(cls):
super(TestOdataFeed, cls).setUpClass()
cls.client = Client()
cls.domain = Domain(name='test_domain')
cls.domain.save()
cls.web_user = WebUser.create(cls.domain.name, 'test_user', 'my_password')
cls.account, _ = BillingAccount.get_or_create_account_by_domain(cls.domain.name, created_by='')
plan_version = DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.STANDARD)
cls.subscription = Subscription.new_domain_subscription(cls.account, cls.domain.name, plan_version)
def setUp(self):
self._clear_docs()
self.domain = create_domain(DOMAIN)
self.account = BillingAccount.get_or_create_account_by_domain(DOMAIN, created_by="automated-test")[0]
plan = DefaultProductPlan.get_default_plan_by_domain(DOMAIN, edition=SoftwarePlanEdition.ADVANCED)
self.subscription = Subscription.new_domain_subscription(self.account, DOMAIN, plan)
self.subscription.is_active = True
self.subscription.save()
self.couch_user = WebUser.create(None, "test", "foobar")
self.couch_user.add_domain_membership(DOMAIN, is_admin=True)
self.couch_user.save()
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_preexisting_current_subscription(self):
preexisting_subscription = Subscription.new_domain_subscription(
self._preexisting_subscription_account,
self.domain.name,
self._random_plan_version,
)
self._assign_community_subscriptions()
self.assertEqual(Subscription.objects.count(), 1)
self.assertFalse(Subscription.objects.exclude(subscriber__domain=self.domain.name).exists())
self.assertEqual(Subscription.objects.all()[0], preexisting_subscription)
def _setup_subscription(cls, domain_name, software_plan):
plan = DefaultProductPlan.get_default_plan_version(edition=software_plan)
account = BillingAccount.get_or_create_account_by_domain(
domain_name, created_by="automated-test" + cls.__name__
)[0]
subscription = Subscription.new_domain_subscription(
account,
domain_name,
plan,
date_start=datetime.date.today() - datetime.timedelta(days=1),
date_end=datetime.date.today() + datetime.timedelta(days=5))
subscription.save()
