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 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):
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 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 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 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):
update_toggle_cache(MODULE_FILTER.slug, 'domain', True, NAMESPACE_DOMAIN)
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
def __enter__(self):
update_toggle_cache(self.toggle_slug, self.item, True, namespace=self.namespace)
