def handle(self, *args, **options): dry_run = options.get('dry_run', False) if dry_run: print("\n-------- DRY RUN --------\n") slug = CALLCENTER.slug try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) print("Current domains in toggle: {}".format(toggle.enabled_users)) domains = get_call_center_domains() print("Active call center domains: {}".format(domains)) items = [namespaced_item(domain, NAMESPACE_DOMAIN) for domain in domains] missing = set(items) - set(toggle.enabled_users) print("Domains missing from toggle: {}".format(missing)) toggle.enabled_users = items if not dry_run: toggle.save() for item in items: update_toggle_cache(slug, item, True)
def do_setup(cls): cls.project = create_domain(cls.domain) cls.password = "******" def create_user(username): username = format_username(username, cls.domain) return CommCareUser.create(cls.domain, username, cls.password) cls.users = [create_user(id) for id in cls.user_ids] def create_case_set(user, child_user): # for each user we need one open and one closed case of # two different types. for type in cls.case_types: c1 = _create_case(user, type, close=False) # open _create_case(user, type, close=True) # closed # child _create_case(child_user, _child_case_type(type), close=False, index={'parent': ('parent-case', c1.case_id)}) for i, user in enumerate(cls.users): create_case_set(user, cls.users[(i + 1) % len(cls.users)]) cls.test_type = cls.case_types[0] cls.test_user_id = cls.users[0]._id update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN, True, toggles.NAMESPACE_DOMAIN)
def handle(self, *args, **options): dry_run = options.get('dry_run', False) if dry_run: print("\n-------- DRY RUN --------\n") slug = CALLCENTER.slug try: toggle = Toggle.get(slug) except ResourceNotFound: toggle = Toggle(slug=slug) print("Current domains in toggle: {}".format(toggle.enabled_users)) domains = get_call_center_domains() print("Active call center domains: {}".format(domains)) items = [ namespaced_item(domain, NAMESPACE_DOMAIN) for domain in domains ] missing = set(items) - set(toggle.enabled_users) print("Domains missing from toggle: {}".format(missing)) toggle.enabled_users = items if not dry_run: toggle.save() for item in items: update_toggle_cache(slug, item, True)
def setUp(self): create_domain(self.domain) self.password = "******" def create_user(username): return CommCareUser.create(self.domain, format_username(username, self.domain), self.password) self.users = [create_user(id) for id in self.user_ids] def create_case_set(user, child_user): # for each user we need one open and one closed case of # two different types. for type in self.case_types: c1 = _create_case(user, type, close=False) # open _create_case(user, type, close=True) # closed # child _create_case(child_user, _child_case_type(type), close=False, index={'parent': ('parent-case', c1._id)}) for i, user in enumerate(self.users): create_case_set(user, self.users[(i + 1) % len(self.users)]) self.test_type = self.case_types[0] self.test_user_id = self.users[0]._id update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN, True, toggles.NAMESPACE_DOMAIN)
def setUp(self): update_toggle_cache(MODULE_FILTER.slug, DOMAIN, True, NAMESPACE_DOMAIN) self.factory = AppFactory(domain=DOMAIN) self.module_0, _ = self.factory.new_basic_module('parent', 'gold-fish') self.module_1, _ = self.factory.new_module(self.child_module_class, 'child', 'guppy', parent_module=self.module_0) self.app = self.factory.app
def setUpClass(cls): delete_all_users() cls.report_id = '7b97e8b53d00d43ca126b10093215a9d' cls.report_config_uuid = 'a98c812873986df34fd1b4ceb45e6164ae9cc664' cls.domain = 'report-filter-test-domain' cls.user = create_restore_user( domain=cls.domain, username='******', ) update_toggle_cache(MOBILE_UCR.slug, cls.domain, True, NAMESPACE_DOMAIN) report_configuration = cls.make_report_config(cls.domain, cls.report_id) cls.report_configs_by_id = {cls.report_id: report_configuration} cls.app = Application.new_app(cls.domain, "Report Filter Test App", APP_V2) module = cls.app.add_module( ReportModule.new_module("Report Module", 'en')) module.report_configs.append( ReportAppConfig( report_id=cls.report_id, header={}, description="", graph_configs={ '7451243209119342931': ReportGraphConfig(series_configs={'count': {}}) }, filters={ 'computed_owner_name_40cc88a0_1': MobileSelectFilter() }, uuid=cls.report_config_uuid, )) with mock_report_configurations(cls.report_configs_by_id): cls.suite = cls.app.create_suite() cls.data = [ { 'color_94ec39e6': 'red', 'count': 2, 'computed_owner_name_40cc88a0': 'cory' }, { 'color_94ec39e6': 'black', 'count': 1, 'computed_owner_name_40cc88a0': 'ctsims' }, { 'color_94ec39e6': 'red', 'count': 3, 'computed_owner_name_40cc88a0': 'daniel' }, ] with mock_report_data(cls.data): with mock_report_configuration_get(cls.report_configs_by_id): with mock.patch( 'corehq.apps.app_manager.fixtures.mobile_ucr.get_apps_in_domain', lambda domain, include_remote: [cls.app]): fixture, = report_fixture_generator(cls.user, '2.0') cls.fixture = ElementTree.tostring(fixture)
def setUp(self): self.app = Application(build_spec=BuildSpec(version='2.7.0'), name="TÉST ÁPP", domain="potter", langs=['en']) update_toggle_cache(toggles.CUSTOM_PROPERTIES.slug, 'potter', True, toggles.NAMESPACE_DOMAIN)
def setUpClass(cls): super(ReportFiltersSuiteTest, cls).setUpClass() delete_all_users() cls.report_id = '7b97e8b53d00d43ca126b10093215a9d' cls.report_config_uuid = 'a98c812873986df34fd1b4ceb45e6164ae9cc664' cls.domain = 'report-filter-test-domain' cls.user = create_restore_user( domain=cls.domain, username='******', ) update_toggle_cache(MOBILE_UCR.slug, cls.domain, True, NAMESPACE_DOMAIN) report_configuration = cls.make_report_config(cls.domain, cls.report_id) cls.report_configs_by_id = { cls.report_id: report_configuration } cls.app = Application.new_app(cls.domain, "Report Filter Test App") module = cls.app.add_module(ReportModule.new_module("Report Module", 'en')) module.report_configs.append( ReportAppConfig( report_id=cls.report_id, header={}, description="", complete_graph_configs={ '7451243209119342931': GraphConfiguration( graph_type="bar", series=[GraphSeries( config={}, locale_specific_config={}, data_path="", x_function="", y_function="", )], ) }, filters={ 'computed_owner_name_40cc88a0_1': MobileSelectFilter(), 'fav_fruit_abc123_1': MobileSelectFilter() }, uuid=cls.report_config_uuid, ) ) with mock_report_configurations(cls.report_configs_by_id): cls.suite = cls.app.create_suite() cls.data = [ {'color_94ec39e6': 'red', 'count': 2, 'computed_owner_name_40cc88a0': 'cory', 'fav_fruit_abc123': 'c'}, {'color_94ec39e6': 'black', 'count': 1, 'computed_owner_name_40cc88a0': 'ctsims', 'fav_fruit_abc123': 'b'}, {'color_94ec39e6': 'red', 'count': 3, 'computed_owner_name_40cc88a0': 'daniel', 'fav_fruit_abc123': 'b'}, ] with mock_report_data(cls.data): with mock_report_configuration_get(cls.report_configs_by_id): with mock.patch('corehq.apps.app_manager.fixtures.mobile_ucr.get_apps_in_domain', lambda domain, include_remote: [cls.app]): with mock_sql_backend(): with mock_datasource_config(): fixture, = call_fixture_generator(report_fixture_generator, cls.user) cls.fixture = ElementTree.tostring(fixture)
def setUp(self): self.app = Application(build_spec=BuildSpec( version='2.7.0' ), name=u"TÉST ÁPP", domain="potter" ) update_toggle_cache(toggles.CUSTOM_PROPERTIES.slug, 'potter', True, toggles.NAMESPACE_DOMAIN)
def setUp(self): self.app = Application.new_app('domain', "Untitled Application", application_version=APP_V2) update_toggle_cache(MODULE_FILTER.slug, self.app.domain, True, NAMESPACE_DOMAIN) self.module_0 = self.app.add_module(Module.new_module('parent', None)) self.module_0.unique_id = 'm0' self.module_1 = self.app.add_module(self.child_module_class.new_module("child", None)) self.module_1.unique_id = 'm1' for m_id in range(2): self.app.new_form(m_id, "Form", None)
def setUpClass(cls): super(CaseAPITest, cls).setUpClass() create_domain(cls.domain) cls.password = "******" def create_user(username): return CommCareUser.create(cls.domain, format_username(username, cls.domain), cls.password) cls.users = [create_user(id) for id in cls.user_ids] update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, TEST_DOMAIN, True, toggles.NAMESPACE_DOMAIN)
def setUpClass(cls): super(CaseAPIMiscTests, cls).setUpClass() cls.domain = uuid.uuid4().hex cls.project = create_domain(cls.domain) cls.username = uuid.uuid4().hex cls.password = "******" cls.user = CommCareUser.create( cls.domain, format_username(cls.username, cls.domain), cls.password ) update_toggle_cache(toggles.CLOUDCARE_CACHE.slug, cls.domain, True, toggles.NAMESPACE_DOMAIN)
def setUp(self): self.app = Application.new_app('domain', "Untitled Application", application_version=APP_V2) update_toggle_cache(MODULE_FILTER.slug, self.app.domain, True, NAMESPACE_DOMAIN) self.module_0 = self.app.add_module(Module.new_module('parent', None)) self.module_0.unique_id = 'm0' self.module_1 = self.app.add_module( self.child_module_class.new_module("child", None)) self.module_1.unique_id = 'm1' for m_id in range(2): self.app.new_form(m_id, "Form", None)
def update_toggle(self): """ This turns on the special stock handler when EWS is enabled. """ toggle = Toggle.get(STOCK_AND_RECEIPT_SMS_HANDLER.slug) toggle_user_key = namespaced_item(self.domain, NAMESPACE_DOMAIN) if self.enabled and toggle_user_key not in toggle.enabled_users: toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache( STOCK_AND_RECEIPT_SMS_HANDLER.slug, toggle_user_key, True )
def handle(self, *args, **options): domains = Domain.get_all() for domain in domains: if domain.commtrack_enabled: toggle = Toggle.get(LOCATIONS.slug) toggle_user_key = namespaced_item(domain.name, NAMESPACE_DOMAIN) if toggle_user_key not in toggle.enabled_users: toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache(LOCATIONS.slug, toggle_user_key, True) if not domain.locations_enabled: domain.locations_enabled = True domain.save()
def setUpClass(cls): delete_all_users() cls.report_id = '7b97e8b53d00d43ca126b10093215a9d' cls.report_config_uuid = 'a98c812873986df34fd1b4ceb45e6164ae9cc664' cls.domain = 'report-filter-test-domain' cls.user = create_restore_user( domain=cls.domain, username='******', ) update_toggle_cache(MOBILE_UCR.slug, cls.domain, True, NAMESPACE_DOMAIN) report_configuration = cls.make_report_config(cls.domain, cls.report_id) cls.report_configs_by_id = { cls.report_id: report_configuration } cls.app = Application.new_app(cls.domain, "Report Filter Test App") module = cls.app.add_module(ReportModule.new_module("Report Module", 'en')) module.report_configs.append( ReportAppConfig( report_id=cls.report_id, header={}, description="", graph_configs={ '7451243209119342931': ReportGraphConfig( series_configs={'count': {}} ) }, filters={'computed_owner_name_40cc88a0_1': MobileSelectFilter()}, uuid=cls.report_config_uuid, ) ) with mock_report_configurations(cls.report_configs_by_id): cls.suite = cls.app.create_suite() cls.data = [ {'color_94ec39e6': 'red', 'count': 2, 'computed_owner_name_40cc88a0': 'cory'}, {'color_94ec39e6': 'black', 'count': 1, 'computed_owner_name_40cc88a0': 'ctsims'}, {'color_94ec39e6': 'red', 'count': 3, 'computed_owner_name_40cc88a0': 'daniel'}, ] with mock_report_data(cls.data): with mock_report_configuration_get(cls.report_configs_by_id): with mock.patch('corehq.apps.app_manager.fixtures.mobile_ucr.get_apps_in_domain', lambda domain, include_remote: [cls.app]): with mock_sql_backend(): with mock_datasource_config(): fixture, = report_fixture_generator(cls.user, '2.0') cls.fixture = ElementTree.tostring(fixture)
def test_toggle_cache(self): ns = 'ns' toggle = Toggle(slug=self.slug, enabled_users=['mojer', namespaced_item('fizbod', ns)]) toggle.save() self.assertTrue(toggle_enabled(self.slug, 'mojer')) self.assertFalse(toggle_enabled(self.slug, 'fizbod')) self.assertTrue(toggle_enabled(self.slug, 'fizbod', namespace=ns)) update_toggle_cache(self.slug, 'mojer', False) update_toggle_cache(self.slug, 'fizbod', False, namespace=ns) self.assertFalse(toggle_enabled(self.slug, 'mojer')) self.assertFalse(toggle_enabled(self.slug, 'fizbod', namespace=ns)) clear_toggle_cache(self.slug, 'mojer') clear_toggle_cache(self.slug, 'fizbod', namespace=ns) self.assertTrue(toggle_enabled(self.slug, 'mojer')) self.assertTrue(toggle_enabled(self.slug, 'fizbod', namespace=ns))
def move_toggles(from_toggle_id, to_toggle_id): """ Moves all enabled items from one toggle to another. """ try: from_toggle = Toggle.get(from_toggle_id) except ResourceNotFound: # if no source found this is a noop return try: to_toggle = Toggle.get(to_toggle_id) except ResourceNotFound: to_toggle = Toggle(slug=to_toggle_id, enabled_users=[]) for item in from_toggle.enabled_users: if item not in to_toggle.enabled_users: to_toggle.enabled_users.append(item) update_toggle_cache(to_toggle_id, item, True) to_toggle.save() from_toggle.delete()
def setUp(self): update_toggle_cache(MODULE_FILTER.slug, 'skelly', True, NAMESPACE_DOMAIN) update_toggle_cache(MODULE_FILTER.slug, 'domain', True, NAMESPACE_DOMAIN) update_toggle_cache(MODULE_FILTER.slug, 'example', True, NAMESPACE_DOMAIN) self.suite_xml_is_usercase_in_use_patch = patch('corehq.apps.app_manager.suite_xml.is_usercase_in_use') self.suite_xml_is_usercase_in_use_mock = self.suite_xml_is_usercase_in_use_patch.start() self.suite_xml_is_usercase_in_use_mock.return_value = True
def setUp(self): update_toggle_cache(MODULE_FILTER.slug, 'skelly', True, NAMESPACE_DOMAIN) update_toggle_cache(MODULE_FILTER.slug, 'domain', True, NAMESPACE_DOMAIN) update_toggle_cache(MODULE_FILTER.slug, 'example', True, NAMESPACE_DOMAIN) self.suite_xml_is_usercase_in_use_patch = patch( 'corehq.apps.app_manager.suite_xml.is_usercase_in_use') self.suite_xml_is_usercase_in_use_mock = self.suite_xml_is_usercase_in_use_patch.start( ) self.suite_xml_is_usercase_in_use_mock.return_value = True
def request_new_domain(request, form, org, domain_type=None, new_user=True): now = datetime.utcnow() current_user = CouchUser.from_django_user(request.user) commtrack_enabled = domain_type == 'commtrack' dom_req = RegistrationRequest() if new_user: dom_req.request_time = now dom_req.request_ip = get_ip(request) dom_req.activation_guid = uuid.uuid1().hex new_domain = Domain( name=form.cleaned_data['domain_name'], is_active=False, date_created=datetime.utcnow(), commtrack_enabled=commtrack_enabled, locations_enabled=commtrack_enabled, creating_user=current_user.username, secure_submissions=True, ) if commtrack_enabled: toggle_user_key = namespaced_item(new_domain.name, NAMESPACE_DOMAIN) # enable commtrack toggle toggle = Toggle.get(COMMTRACK.slug) toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache(COMMTRACK.slug, toggle_user_key, True) # enable location toggle toggle = Toggle.get(LOCATIONS.slug) toggle.enabled_users.append(toggle_user_key) toggle.save() update_toggle_cache(LOCATIONS.slug, toggle_user_key, True) if form.cleaned_data.get('domain_timezone'): new_domain.default_timezone = form.cleaned_data['domain_timezone'] if org: new_domain.organization = org new_domain.hr_name = request.POST.get('domain_hrname', None) or new_domain.name if not new_user: new_domain.is_active = True # ensure no duplicate domain documents get created on cloudant new_domain.save(**get_safe_write_kwargs()) if not new_domain.name: new_domain.name = new_domain._id new_domain.save() # we need to get the name from the _id create_30_day_trial(new_domain) dom_req.domain = new_domain.name if request.user.is_authenticated(): if not current_user: current_user = WebUser() current_user.sync_from_django_user(request.user) current_user.save() current_user.add_domain_membership(new_domain.name, is_admin=True) current_user.save() dom_req.requesting_user_username = request.user.username dom_req.new_user_username = request.user.username if new_user: dom_req.save() send_domain_registration_email(request.user.email, dom_req.domain, dom_req.activation_guid) else: send_global_domain_registration_email(request.user, new_domain.name) send_new_request_update_email(request.user, get_ip(request), new_domain.name, is_new_user=new_user)
def setUp(self): super(FileResponseStateHashTest, self).setUp() update_toggle_cache(toggles.FILE_RESTORE.slug, self.user.username, True)
def setUp(self): update_toggle_cache(MODULE_FILTER.slug, 'domain', True, NAMESPACE_DOMAIN)
def test_outgoing_failure_indefinite_retry(self, process_sms_delay_mock, enqueue_directly_mock): timestamp = datetime(2016, 1, 1, 12, 0) update_toggle_cache(RETRY_SMS_INDEFINITELY.slug, self.domain, True, NAMESPACE_DOMAIN) with patch_datetime_api(timestamp): send_sms(self.domain, None, '+999123', 'test outgoing') self.assertEqual(enqueue_directly_mock.call_count, 1) self.assertEqual(self.queued_sms_count, 1) self.assertEqual(self.reporting_sms_count, 0) for i in range(settings.SMS_QUEUE_MAX_PROCESSING_ATTEMPTS): queued_sms = self.get_queued_sms() self.assertEqual(queued_sms.domain, self.domain) self.assertEqual(queued_sms.phone_number, '+999123') self.assertEqual(queued_sms.text, 'test outgoing') self.assertEqual(queued_sms.datetime_to_process, timestamp) self.assertEqual(queued_sms.processed, False) self.assertEqual(queued_sms.error, False) self.assertEqual(queued_sms.num_processing_attempts, i) with patch_failed_send() as send_mock, patch_datetime_tasks( timestamp + timedelta(seconds=1)): process_sms(queued_sms.pk) self.assertEqual(process_sms_delay_mock.call_count, 0) self.assertBillableDoesNotExist(queued_sms.couch_id) self.assertEqual(send_mock.call_count, 1) self.assertEqual(self.queued_sms_count, 1) self.assertEqual(self.reporting_sms_count, 0) timestamp += timedelta( minutes=settings.SMS_QUEUE_REPROCESS_INTERVAL) timestamp += (timedelta( minutes=settings.SMS_QUEUE_REPROCESS_INDEFINITELY_INTERVAL) - timedelta(minutes=settings.SMS_QUEUE_REPROCESS_INTERVAL)) queued_sms = self.get_queued_sms() self.assertEqual(queued_sms.domain, self.domain) self.assertEqual(queued_sms.phone_number, '+999123') self.assertEqual(queued_sms.text, 'test outgoing') self.assertEqual(queued_sms.datetime_to_process, timestamp) self.assertEqual(queued_sms.processed, False) self.assertEqual(queued_sms.error, False) self.assertEqual(queued_sms.num_processing_attempts, settings.SMS_QUEUE_MAX_PROCESSING_ATTEMPTS) with patch_successful_send() as send_mock, patch_datetime_tasks( timestamp + timedelta(seconds=1)): process_sms(queued_sms.pk) self.assertEqual(send_mock.call_count, 1) self.assertEqual(self.queued_sms_count, 0) self.assertEqual(self.reporting_sms_count, 1) reporting_sms = self.get_reporting_sms() self.assertEqual(reporting_sms.processed, True) self.assertEqual(reporting_sms.error, False) self.assertEqual(reporting_sms.num_processing_attempts, settings.SMS_QUEUE_MAX_PROCESSING_ATTEMPTS + 1) self.assertEqual(process_sms_delay_mock.call_count, 0) self.assertBillableExists(reporting_sms.couch_id)
def setUp(self): update_toggle_cache(FILE_RESTORE.slug, USERNAME, True) super(FileRestoreSyncTokenCachingTest, self).setUp()
def __enter__(self): update_toggle_cache(self.toggle_slug, self.item, True, namespace=self.namespace)
def setUp(self): super(AutomaticCaseUpdateTest, self).setUp() self.domain = 'auto-update-test' update_toggle_cache(AUTO_CASE_UPDATE_ENHANCEMENTS.slug, self.domain, True, NAMESPACE_DOMAIN) update_toggle_cache(RUN_AUTO_CASE_UPDATES_ON_SAVE.slug, self.domain, True, NAMESPACE_DOMAIN) self.case_db = CaseAccessors(self.domain) self.factory = CaseFactory(self.domain) self.rule = AutomaticUpdateRule( domain=self.domain, name='test-rule', case_type='test-case-type', active=True, server_modified_boundary=30, ) self.rule.save() AutomaticUpdateRuleCriteria.objects.create( property_name='last_visit_date', property_value='30', match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_AFTER, rule=self.rule, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_UPDATE, property_name='update_flag', property_value='Y', rule=self.rule, ) self.rule2 = AutomaticUpdateRule( domain=self.domain, name='test-rule-2', case_type='test-case-type-2', active=True, server_modified_boundary=30, ) self.rule2.save() AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_CLOSE, rule=self.rule2, ) self.rule3 = AutomaticUpdateRule( domain=self.domain, name='test-rule-3', case_type='test-case-type-2', active=True, server_modified_boundary=50, ) self.rule3.save() AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_CLOSE, rule=self.rule3, ) self.rule4 = AutomaticUpdateRule( domain=self.domain, name='test-rule-4', case_type='test-case-type', active=True, server_modified_boundary=30, ) self.rule4.save() AutomaticUpdateRuleCriteria.objects.create( property_name='last_visit_date', property_value='40', match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_AFTER, rule=self.rule4, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_UPDATE, property_name='update_flag', property_value='C', rule=self.rule4, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_CLOSE, rule=self.rule4, ) self.rule5 = AutomaticUpdateRule(domain=self.domain, name='test-rule-5', case_type='test-case-type-3', active=True, filter_on_server_modified=False) self.rule5.save() AutomaticUpdateRuleCriteria.objects.create( property_name='name', property_value='signal', match_type=AutomaticUpdateRuleCriteria.MATCH_EQUAL, rule=self.rule5, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_UPDATE, property_name='after_save', property_value='updated', rule=self.rule5, ) with drop_connected_signals(case_post_save): case = self.factory.create_case(case_type='test-case-type')
def setUp(self): update_toggle_cache(toggles.FILE_RESTORE.slug, DUMMY_USERNAME, True) super(FileRestoreOtaRestoreTest, self).setUp()
def setUp(self): super(AutomaticCaseUpdateTest, self).setUp() self.domain = 'auto-update-test' update_toggle_cache(AUTO_CASE_UPDATE_ENHANCEMENTS.slug, self.domain, True, NAMESPACE_DOMAIN) update_toggle_cache(RUN_AUTO_CASE_UPDATES_ON_SAVE.slug, self.domain, True, NAMESPACE_DOMAIN) self.case_db = CaseAccessors(self.domain) self.factory = CaseFactory(self.domain) self.rule = AutomaticUpdateRule( domain=self.domain, name='test-rule', case_type='test-case-type', active=True, server_modified_boundary=30, ) self.rule.save() AutomaticUpdateRuleCriteria.objects.create( property_name='last_visit_date', property_value='30', match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_AFTER, rule=self.rule, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_UPDATE, property_name='update_flag', property_value='Y', rule=self.rule, ) self.rule2 = AutomaticUpdateRule( domain=self.domain, name='test-rule-2', case_type='test-case-type-2', active=True, server_modified_boundary=30, ) self.rule2.save() AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_CLOSE, rule=self.rule2, ) self.rule3 = AutomaticUpdateRule( domain=self.domain, name='test-rule-3', case_type='test-case-type-2', active=True, server_modified_boundary=50, ) self.rule3.save() AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_CLOSE, rule=self.rule3, ) self.rule4 = AutomaticUpdateRule( domain=self.domain, name='test-rule-4', case_type='test-case-type', active=True, server_modified_boundary=30, ) self.rule4.save() AutomaticUpdateRuleCriteria.objects.create( property_name='last_visit_date', property_value='40', match_type=AutomaticUpdateRuleCriteria.MATCH_DAYS_AFTER, rule=self.rule4, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_UPDATE, property_name='update_flag', property_value='C', rule=self.rule4, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_CLOSE, rule=self.rule4, ) self.rule5 = AutomaticUpdateRule( domain=self.domain, name='test-rule-5', case_type='test-case-type-3', active=True, filter_on_server_modified=False ) self.rule5.save() AutomaticUpdateRuleCriteria.objects.create( property_name='name', property_value='signal', match_type=AutomaticUpdateRuleCriteria.MATCH_EQUAL, rule=self.rule5, ) AutomaticUpdateAction.objects.create( action=AutomaticUpdateAction.ACTION_UPDATE, property_name='after_save', property_value='updated', rule=self.rule5, ) with drop_connected_signals(case_post_save): case = self.factory.create_case(case_type='test-case-type') self.case_id = case.case_id