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 test_transfers(self):
advanced_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED)
standard_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.STANDARD)
first_sub = Subscription.new_domain_subscription(
self.account, self.domain.name, advanced_plan)
product_credit = CreditLine.add_credit(
self.product_credit_amt,
subscription=first_sub,
product_type=SoftwareProductType.ANY,
)
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_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 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(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 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(
SoftwarePlanEdition.COMMUNITY
).plan.get_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 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(
SoftwarePlanEdition.COMMUNITY
).plan.get_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 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(
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 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(
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_transfers(self):
advanced_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED
)
standard_plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.STANDARD
)
first_sub = Subscription.new_domain_subscription(
self.account, self.domain.name, advanced_plan
)
product_credit = CreditLine.add_credit(
self.product_credit_amt, subscription=first_sub,
product_type=SoftwareProductType.ANY,
)
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_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_change_plan_on_renewal(self):
new_edition = SoftwarePlanEdition.ADVANCED
new_plan = DefaultProductPlan.get_default_plan(new_edition)
self.renewed_subscription = self.subscription.renew_subscription(
new_version=new_plan)
self.assertEqual(self.renewed_subscription.plan_version, new_plan)
def test_change_plan_on_renewal(self):
new_edition = SoftwarePlanEdition.ADVANCED
new_plan = DefaultProductPlan.get_default_plan(new_edition)
self.renewed_subscription = self.subscription.renew_subscription(
new_version=new_plan
)
self.assertEqual(self.renewed_subscription.plan_version, new_plan)
def setup_subscription(cls, domain_name, software_plan):
generator.instantiate_accounting()
plan = DefaultProductPlan.get_default_plan(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 prepare_domain(domain_name):
from corehq.apps.commtrack.tests.util 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()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan(
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, all_stock_data=True)
ils_config.save()
fields_definition = CustomDataFieldsDefinition.get_or_create(domain.name, 'LocationFields')
fields_definition.fields.append(CustomDataField(
slug='group',
label='Group',
is_required=False,
choices=['A', 'B', 'C'],
is_multiple_choice=False
))
fields_definition.save()
return domain
def _setup_subscription(cls, domain_name, software_plan):
plan = DefaultProductPlan.get_default_plan(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()
cls._to_delete.append(account)
cls._to_delete.append(subscription)
def _setup_subscription(cls, domain_name, software_plan):
plan = DefaultProductPlan.get_default_plan(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()
cls._to_delete.append(account)
cls._to_delete.append(subscription)
def prepare_domain(domain_name):
domain = create_domain(domain_name)
domain.convert_to_commtrack()
domain.save()
set_domain_default_backend_to_test_backend(domain.name)
def _make_loc_type(name, administrative=False, parent_type=None):
return LocationType.objects.get_or_create(
domain=domain_name,
name=name,
administrative=administrative,
parent_type=parent_type,
)[0]
country = _make_loc_type(name="country", administrative=True)
_make_loc_type(name="Central Medical Store", parent_type=country)
_make_loc_type(name="Teaching Hospital", parent_type=country)
region = _make_loc_type(name="region",
administrative=True,
parent_type=country)
_make_loc_type(name="Regional Medical Store", parent_type=region)
_make_loc_type(name="Regional Hospital", parent_type=region)
district = _make_loc_type(name="district",
administrative=True,
parent_type=region)
_make_loc_type(name="Clinic", parent_type=district)
_make_loc_type(name="District Hospital", parent_type=district)
_make_loc_type(name="Health Centre", parent_type=district)
_make_loc_type(name="CHPS Facility", parent_type=district)
_make_loc_type(name="Hospital", parent_type=district)
_make_loc_type(name="Psychiatric Hospital", parent_type=district)
_make_loc_type(name="Polyclinic", parent_type=district)
_make_loc_type(name="facility", parent_type=district)
generator.instantiate_accounting()
account = BillingAccount.get_or_create_account_by_domain(
domain.name,
created_by="automated-test",
)[0]
plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED)
subscription = Subscription.new_domain_subscription(
account, domain.name, plan)
subscription.is_active = True
subscription.save()
ews_config = EWSGhanaConfig(enabled=True, domain=domain.name)
ews_config.save()
return domain
def setUp(self):
super(TestDomainInvoiceFactory, self).setUp()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.domain = generator.arbitrary_domain()
self.account = BillingAccount.get_or_create_account_by_domain(
domain=self.domain.name, created_by="TEST")[0]
self.community = DefaultProductPlan.get_default_plan(
).plan.get_version()
generator.arbitrary_commcare_users_for_domain(
self.domain.name, self.community.user_limit + 1)
self.invoice_factory = DomainInvoiceFactory(self.invoice_start,
self.invoice_end,
self.domain)
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(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 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 setup_domain(cls, name):
domain_obj = Domain(name=name,
sms_mobile_worker_registration_enabled=True)
domain_obj.save()
plan = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.ADVANCED)
account = BillingAccount.get_or_create_account_by_domain(
name, created_by="automated-test-" + cls.__name__)[0]
subscription = Subscription.new_domain_subscription(
account, name, plan)
subscription.is_active = True
subscription.save()
domain_obj = Domain.get(domain_obj.get_id)
return (domain_obj, account, subscription)
def setUp(self):
super(TestDomainInvoiceFactory, self).setUp()
self.invoice_start, self.invoice_end = get_previous_month_date_range()
self.domain = generator.arbitrary_domain()
self.account = BillingAccount.get_or_create_account_by_domain(
domain=self.domain.name, created_by="TEST"
)[0]
self.community = DefaultProductPlan.get_default_plan().plan.get_version()
generator.arbitrary_commcare_users_for_domain(
self.domain.name, self.community.user_limit + 1
)
self.invoice_factory = DomainInvoiceFactory(
self.invoice_start, self.invoice_end, self.domain
)
def _ensure_full_coverage(self, subscriptions):
plan_version = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.COMMUNITY
).plan.get_version()
if not plan_version.feature_charges_exist_for_domain(self.domain):
return
community_ranges = self._get_community_ranges(subscriptions)
if not community_ranges:
return
# First check to make sure none of the existing subscriptions is set
# to do not invoice. Let's be on the safe side and not send a
# community invoice out, if that's the case.
do_not_invoice = any([s.do_not_invoice for s in subscriptions])
account = BillingAccount.get_or_create_account_by_domain(
self.domain.name,
created_by=self.__class__.__name__,
entry_point=EntryPoint.SELF_STARTED,
)[0]
if account.date_confirmed_extra_charges is None:
log_accounting_info(
"Did not generate invoice because date_confirmed_extra_charges "
"was null for domain %s" % self.domain.name
)
do_not_invoice = True
for start_date, end_date in community_ranges:
# create a new community subscription for each
# date range that the domain did not have a subscription
community_subscription = Subscription(
account=account,
plan_version=plan_version,
subscriber=self.subscriber,
date_start=start_date,
date_end=end_date,
do_not_invoice=do_not_invoice,
)
community_subscription.save()
subscriptions.append(community_subscription)
def create_30_day_advanced_trial(domain_obj):
# Create a 30 Day Trial subscription to the Advanced Plan
advanced_plan_version = DefaultProductPlan.get_default_plan(
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,
pre_or_post_pay=PreOrPostPay.POSTPAY,
)[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,
service_type=SubscriptionType.TRIAL)
trial_subscription.is_active = True
trial_subscription.save()
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 _ensure_full_coverage(self, subscriptions):
plan_version = DefaultProductPlan.get_default_plan(
edition=SoftwarePlanEdition.COMMUNITY).plan.get_version()
if not plan_version.feature_charges_exist_for_domain(self.domain):
return
community_ranges = self._get_community_ranges(subscriptions)
if not community_ranges:
return
# First check to make sure none of the existing subscriptions is set
# to do not invoice. Let's be on the safe side and not send a
# community invoice out, if that's the case.
do_not_invoice = any([s.do_not_invoice for s in subscriptions])
account = BillingAccount.get_or_create_account_by_domain(
self.domain.name,
created_by=self.__class__.__name__,
entry_point=EntryPoint.SELF_STARTED,
)[0]
if account.date_confirmed_extra_charges is None:
log_accounting_info(
"Did not generate invoice because date_confirmed_extra_charges "
"was null for domain %s" % self.domain.name)
do_not_invoice = True
for start_date, end_date in community_ranges:
# create a new community subscription for each
# date range that the domain did not have a subscription
community_subscription = Subscription(
account=account,
plan_version=plan_version,
subscriber=self.subscriber,
date_start=start_date,
date_end=end_date,
do_not_invoice=do_not_invoice,
)
community_subscription.save()
subscriptions.append(community_subscription)
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 _most_recently_created_community_plan_version(self):
return DefaultProductPlan.get_default_plan(edition=SoftwarePlanEdition.COMMUNITY)
def _random_plan_version(self):
return DefaultProductPlan.get_default_plan(
edition=random.choice(SoftwarePlanEdition.SELF_SERVICE_ORDER + [SoftwarePlanEdition.ENTERPRISE]),
)
