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