def test_product_fixture(self):
user = self.user
fixture_xml = self.generate_product_fixture_xml(user)
index_schema, fixture = call_fixture_generator(
product_fixture_generator, user)
self.assertXmlEqual(fixture_xml, fixture)
schema_xml = """
<schema id="commtrack:products">
<indices>
<index>@id</index>
<index>category</index>
<index>code</index>
<index>program_id</index>
</indices>
</schema>
"""
self.assertXmlEqual(schema_xml, ElementTree.tostring(index_schema))
# test restore with different user
user2 = create_restore_user(self.domain, username='******')
self.addCleanup(user2._couch_user.delete)
fixture_xml = self.generate_product_fixture_xml(user2)
index_schema, fixture = call_fixture_generator(
product_fixture_generator, user2)
self.assertXmlEqual(fixture_xml, fixture)
def test_program_fixture_cache(self):
user = self.user
Program(domain=user.domain, name="test1", code="t1").save()
program_list = list(Program.by_domain(user.domain))
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(program_xml, fixture[0])
program = program_list[0]
program.name = 'new_name'
super(Program, program).save() # save but skip clearing the cache
fixture_cached = call_fixture_generator(program_fixture_generator,
user)
self.assertXmlEqual(program_xml, fixture_cached[0])
program.save()
program_xml_new = self.generate_program_xml(program_list, user)
fixture_regen = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(program_xml_new, fixture_regen[0])
self.assertXMLNotEqual(program_xml_new, program_xml)
def test_should_sync_when_changed(self, *args):
self.user._couch_user.add_to_assigned_locations(
self.locations['Boston'])
last_sync_time = datetime.utcnow()
sync_log = SyncLog(date=last_sync_time)
locations_queryset = SQLLocation.objects.filter(
pk=self.locations['Boston'].pk)
restore_state = MockRestoreState(self.user, RestoreParams())
self.assertFalse(
should_sync_locations(sync_log, locations_queryset, restore_state))
self.assertEquals(
len(
call_fixture_generator(related_locations_fixture_generator,
self.user,
last_sync=sync_log)), 0)
LocationRelation.objects.create(location_a=self.locations["Revere"],
location_b=self.locations["Boston"])
self.assertTrue(
should_sync_locations(SyncLog(date=last_sync_time),
locations_queryset, restore_state))
# length 2 for index definition + data
self.assertEquals(
len(
call_fixture_generator(related_locations_fixture_generator,
self.user,
last_sync=sync_log)), 2)
def test_program_fixture(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture[0])
)
# test restore with different user
user2 = create_restore_user(self.domain, username='******')
self.addCleanup(user2._couch_user.delete)
program_xml = self.generate_program_xml(program_list, user2)
fixture = call_fixture_generator(program_fixture_generator, user2)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture[0])
)
def test_selective_product_sync(self):
user = self.user
expected_xml = self.generate_product_fixture_xml(user)
product_list = Product.by_domain(user.domain)
self._initialize_product_names(len(product_list))
fixture_original = call_fixture_generator(product_fixture_generator, user)[1]
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_original)
)
first_sync = sorted(SyncLog.view(
"phone/sync_logs_by_user",
include_docs=True,
reduce=False
).all(), key=lambda x: x.date)[-1]
# make sure the time stamp on this first sync is
# not on the same second that the products were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no products synced
fixture_pre_change = call_fixture_generator(product_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = sorted(SyncLog.view(
"phone/sync_logs_by_user",
include_docs=True,
reduce=False
).all(), key=lambda x: x.date)[-1]
self.assertTrue(first_sync._id != second_sync._id)
# save should make the product more recently updated than the
# last sync
for product in product_list:
product.save()
# now that we've updated a product, we should get
# product data in sync again
fixture_post_change = call_fixture_generator(product_fixture_generator, user, last_sync=second_sync)[1]
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_post_change)
)
def test_selective_program_sync(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture_original = call_fixture_generator(program_fixture_generator, user)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_original[0])
)
first_sync = self._get_latest_synclog()
# make sure the time stamp on this first sync is
# not on the same second that the programs were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no programs synced
fixture_pre_change = call_fixture_generator(program_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = self._get_latest_synclog()
self.assertTrue(first_sync._id != second_sync._id)
# save should make the program more recently updated than the
# last sync
for program in program_list:
program.save()
# now that we've updated a program, we should get
# program data in sync again
fixture_post_change = call_fixture_generator(program_fixture_generator, user, last_sync=second_sync)
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_post_change[0])
)
def test_selective_program_sync(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture_original = call_fixture_generator(program_fixture_generator, user)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_original[0])
)
first_sync = self._get_latest_synclog()
# make sure the time stamp on this first sync is
# not on the same second that the programs were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no programs synced
fixture_pre_change = call_fixture_generator(program_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = self._get_latest_synclog()
self.assertTrue(first_sync._id != second_sync._id)
# save should make the program more recently updated than the
# last sync
for program in program_list:
program.save()
# now that we've updated a program, we should get
# program data in sync again
fixture_post_change = call_fixture_generator(program_fixture_generator, user, last_sync=second_sync)
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture_post_change[0])
)
def test_selective_product_sync(self):
user = self.user
expected_xml = self.generate_product_fixture_xml(user)
product_list = Product.by_domain(user.domain)
self._initialize_product_names(len(product_list))
fixture_original = call_fixture_generator(product_fixture_generator, user)[1]
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_original)
)
first_sync = self._get_latest_synclog()
# make sure the time stamp on this first sync is
# not on the same second that the products were created
first_sync.date += datetime.timedelta(seconds=1)
# second sync is before any changes are made, so there should
# be no products synced
fixture_pre_change = call_fixture_generator(product_fixture_generator, user, last_sync=first_sync)
deprecated_generate_restore_payload(self.domain_obj, user)
self.assertEqual(
[],
fixture_pre_change,
"Fixture was not empty on second sync"
)
second_sync = self._get_latest_synclog()
self.assertTrue(first_sync._id != second_sync._id)
# save should make the product more recently updated than the
# last sync
for product in product_list:
product.save()
# now that we've updated a product, we should get
# product data in sync again
fixture_post_change = call_fixture_generator(product_fixture_generator, user, last_sync=second_sync)[1]
# regenerate the fixture xml to make sure it is still legit
self.assertXmlEqual(
expected_xml,
ElementTree.tostring(fixture_post_change)
)
def test_no_user_locations_returns_empty(self):
empty_fixture = EMPTY_LOCATION_FIXTURE_TEMPLATE.format(
self.user.user_id)
fixture = ElementTree.tostring(call_fixture_generator(
location_fixture_generator, self.user)[0],
encoding='utf-8')
self.assertXmlEqual(empty_fixture, fixture)
def test_callcenter_fixture_commcare_user(self):
user = CommCareUser(_id='123', username="******")
indicator_set = MockIndicatorSet(name='test',
indicators=OrderedDict([
('user_case1', {
'i1': 1,
'i2': 2
}),
('user_case2', {
'i1': 0,
'i2': 3
})
]))
restore_user = type(
'OTARestoreCommCareUserFake', (OTARestoreCommCareUser, ), {
'project': Domain(name='test', default_timezone='UTC'),
'get_call_center_indicators':
lambda self, config: indicator_set,
})('test', user)
fixture, = call_fixture_generator(mock_indicators_fixture_generator,
restore_user)
check_xml_line_by_line(
self, ElementTree.tostring(fixture),
ElementTree.tostring(gen_fixture(restore_user, indicator_set)))
def test_fixture_provider(self, _get_permission_checker):
_get_permission_checker().can_view_registry_data.return_value = True
list_fixture, domains_fixture = call_fixture_generator(
registry_fixture_generator,
self.restore_user,
project=self.domain_obj)
expected_list_fixture = f"""
<fixture id="registry:list">
<registry_list>
<registry slug="{self.registry.slug}" owner="{self.domain}" active="true">
<name>{self.registry.name}</name>
<description></description>
</registry>
</registry_list>
</fixture>"""
expected_domains_fixture = f"""
<fixture id="registry:domains:{self.registry.slug}">
<domains>
<domain name="domain1">domain1</domain>
<domain name="domain2">domain2</domain>
<domain name="{self.domain}">{self.domain_obj.hr_name}</domain>
</domains>
</fixture>
"""
self.assertXmlEqual(
expected_list_fixture,
ElementTree.tostring(list_fixture, encoding='utf-8'))
self.assertXmlEqual(
expected_domains_fixture,
ElementTree.tostring(domains_fixture, encoding='utf-8'))
def test_report_fixtures_provider_with_cloudcare(self):
"""
ReportFixturesProvider should iterate only allowed apps if sync is from cloudcare
"""
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
role = UserRole(
domain=self.domain,
permissions=Permissions(
view_web_apps=False,
view_web_apps_list=[self.app1._id]
),
name='WebApp Restricted'
)
role.save()
self.user._couch_user.set_role(self.domain, role.get_qualified_id())
with patch.object(ConfigurableReportDataSource, 'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
with mock_datasource_config():
fixtures = call_fixture_generator(
report_fixture_generator,
self.user,
device_id="WebAppsLogin|[email protected]"
)
reports = fixtures[0].findall('.//report')
self.assertEqual(len(reports), 1)
self.assertEqual(reports[0].attrib.get('id'), '123456')
def test_ownership(self):
self.assertItemsEqual([self.data_item.get_id],
FixtureDataItem.by_user(self.user, wrap=False))
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
fixture, = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
check_xml_line_by_line(
self, """
<fixture id="item-list:district" user_id="%s">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
""" % self.user.user_id, ElementTree.tostring(fixture))
self.data_item.remove_user(self.user)
self.assertItemsEqual([], self.data_item.get_all_users())
self.fixture_ownership = self.data_item.add_user(self.user)
self.assertItemsEqual([self.user.get_id],
self.data_item.get_all_users(wrap=False))
def test_should_sync_when_changed(self, *args):
self.user._couch_user.add_to_assigned_locations(self.locations['Boston'])
last_sync_time = datetime.utcnow()
sync_log = SyncLog(date=last_sync_time)
locations_queryset = SQLLocation.objects.filter(pk=self.locations['Boston'].pk)
self.assertFalse(should_sync_locations(sync_log, locations_queryset, self.user))
self.assertEquals(
len(call_fixture_generator(related_locations_fixture_generator, self.user, last_sync=sync_log)), 0)
LocationRelation.objects.create(location_a=self.locations["Revere"], location_b=self.locations["Boston"])
self.assertTrue(should_sync_locations(SyncLog(date=last_sync_time), locations_queryset, self.user))
# length 2 for index definition + data
self.assertEquals(
len(call_fixture_generator(related_locations_fixture_generator, self.user, last_sync=sync_log)), 2)
def test_fixture_defaults(self):
user = CommCareUser(_id=uuid.uuid4().hex, domain='test-calendar-defaults')
fixture = call_fixture_generator(calendar_fixture_generator, user)[0]
self.assertEqual(user._id, fixture.attrib['user_id'])
today = datetime.today()
self._check_first_date(fixture, today - timedelta(days=DEFAULT_DAYS_BEFORE))
self._check_last_date(fixture, today + timedelta(days=DEFAULT_DAYS_AFTER))
def test_report_fixtures_provider_with_cloudcare(self):
"""
ReportFixturesProvider should iterate only allowed apps if sync is from cloudcare
"""
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
role = UserRole(
domain=self.domain,
permissions=Permissions(
view_web_apps=False,
view_web_apps_list=[self.app1._id]
),
name='WebApp Restricted'
)
role.save()
self.user._couch_user.set_role(self.domain, role.get_qualified_id())
with patch.object(ConfigurableReportDataSource, 'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
with mock_sql_backend():
with mock_datasource_config():
fixtures = call_fixture_generator(
report_fixture_generator,
self.user,
device_id="WebAppsLogin|[email protected]"
)
reports = fixtures[0].findall('.//report')
self.assertEqual(len(reports), 1)
self.assertEqual(reports[0].attrib.get('id'), '123456')
def test_fixture_is_indexed(self):
self.data_type.fields[
2].is_indexed = True # Set "district_id" as indexed
self.data_type.save()
fixtures = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
self.assertEqual(len(fixtures), 2)
check_xml_line_by_line(
self, """
<fixtures>
<schema id="item-list:district">
<indices>
<index>district_id</index>
</indices>
</schema>
<fixture id="item-list:district" indexed="true" user_id="{}">
<district_list>
<district>
<state_name>Delhi_state</state_name>
<district_name lang="hin">Delhi_in_HIN</district_name>
<district_name lang="eng">Delhi_in_ENG</district_name>
<district_id>Delhi_id</district_id>
</district>
</district_list>
</fixture>
</fixtures>
""".format(self.user.user_id), """
<fixtures>
{}
{}
</fixtures>
""".format(
*[ElementTree.tostring(fixture) for fixture in fixtures]))
def test_callcenter_fixture_web_user(self):
user = WebUser(_id='123')
restore_user = type('OTARestoreWebUserFake', (OTARestoreWebUser,), {
'project': Domain(name='test', default_timezone='UTC'),
})('test', user)
fixtures = call_fixture_generator(mock_indicators_fixture_generator, restore_user)
self.assertEqual(fixtures, [])
def _assert_fixture_matches_file(self, xml_name, desired_locations, flat=False):
if flat:
generator = flat_location_fixture_generator
else:
generator = location_fixture_generator
fixture = ElementTree.tostring(call_fixture_generator(generator, self.user)[-1], encoding='utf-8')
desired_fixture = self._assemble_expected_fixture(xml_name, desired_locations)
self.assertXmlEqual(desired_fixture, fixture)
def test_callcenter_fixture_web_user(self):
user = WebUser(_id='123')
restore_user = type('OTARestoreWebUserFake' if six.PY3 else b'OTARestoreWebUserFake', (OTARestoreWebUser,), {
'project': Domain(name='test', default_timezone='UTC'),
})('test', user)
fixtures = call_fixture_generator(mock_indicators_fixture_generator, restore_user)
self.assertEqual(fixtures, [])
def test_default_mobile_ucr_sync_interval(self):
"""
When sync interval is set, ReportFixturesProvider should provide reports only if
the interval has passed since the last sync or a new build is being requested.
"""
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
with patch.object(ConfigurableReportDataSource,
'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
with mock_datasource_config():
self.domain_obj.default_mobile_ucr_sync_interval = 4 # hours
two_hours_ago = datetime.utcnow() - timedelta(hours=2)
recent_sync = SimplifiedSyncLog(
domain=self.domain_obj.name,
date=two_hours_ago,
user_id='456',
build_id=self.app1.get_id,
)
recent_sync.save()
fixtures = call_fixture_generator(report_fixture_generator,
self.user,
app=self.app1,
last_sync=recent_sync,
project=self.domain_obj)
reports = self._get_fixture(fixtures,
ReportFixturesProviderV1.id)
self.assertIsNone(reports)
recent_sync_new_build = SimplifiedSyncLog(
domain=self.domain_obj.name,
date=two_hours_ago,
user_id='456',
build_id='123',
)
recent_sync_new_build.save()
fixtures = call_fixture_generator(
report_fixture_generator,
self.user,
app=self.app1,
last_sync=recent_sync_new_build,
project=self.domain_obj)
reports = self._get_fixture(
fixtures, ReportFixturesProviderV1.id).findall('.//report')
self.assertEqual(len(reports), 1)
self.assertEqual(reports[0].attrib.get('id'), '123456')
self.domain_obj.default_mobile_ucr_sync_interval = None
def test_force_empty_when_user_has_no_locations(self, *args):
sync_log = SyncLog(date=datetime.utcnow())
# no relations have been touched since this synclog, but it still pushes down the empty list
self.assertEquals(
len(
call_fixture_generator(related_locations_fixture_generator,
self.user,
last_sync=sync_log)), 2)
def test_location_fixture_generator_domain_no_locations(self):
"""
Ensures that a domain that doesn't use locations doesn't send an empty
location fixture
"""
assert self.user.location is None
fixture = call_fixture_generator(location_fixture_generator,
self.user.to_ota_restore_user())
self.assertEqual(len(fixture), 0)
def test_location_fixture_generator_no_user_location(self):
"""
Ensures that a user without a location will still receive an empty fixture
"""
assert self.user.location is None
fixture = call_fixture_generator(location_fixture_generator,
self.user.to_ota_restore_user())
self.assertEqual(len(fixture), 1)
self.assertEqual(len(fixture[0].findall('.//state')), 0)
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 test_location_fixture_generator_domain_no_locations(self):
"""
Ensures that a domain that doesn't use locations doesn't send an empty
location fixture
"""
self.user.unset_location()
self.addCleanup(self.user.set_location, self.loc)
fixture = call_fixture_generator(location_fixture_generator, self.user.to_ota_restore_user())
self.assertEqual(len(fixture), 0)
def test_location_fixture_generator_domain_no_locations(self):
"""
Ensures that a domain that doesn't use locations doesn't send an empty
location fixture
"""
self.user.unset_location()
self.addCleanup(self.user.set_location, self.loc)
fixture = call_fixture_generator(location_fixture_generator, self.user.to_ota_restore_user())
self.assertEqual(len(fixture), 0)
def test_report_fixtures_provider_with_app_that_doesnt_have_reports(self):
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
with patch.object(ConfigurableReportDataSource,
'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
fixtures = call_fixture_generator(report_fixture_generator,
self.user,
app=self.app3)
self.assertEqual(len(fixtures), 0)
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='******',
)
MOBILE_UCR.set(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=OrderedDict([
('fav_fruit_abc123_1', MobileSelectFilter()),
('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', '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_datasource_config():
fixture, = call_fixture_generator(report_fixture_generator, cls.user)
cls.fixture = ElementTree.tostring(fixture)
def _assert_fixture_has_locations(self,
xml_name,
desired_locations,
flat=False):
generator = flat_location_fixture_generator if flat else location_fixture_generator
fixture = ElementTree.tostring(
call_fixture_generator(generator, self.user)[-1])
desired_fixture = self._assemble_expected_fixture(
xml_name, desired_locations)
self.assertXmlEqual(desired_fixture, fixture)
def test_program_fixture(self):
user = self.user
Program(domain=user.domain, name="test1", code="t1").save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(program_xml, ElementTree.tostring(fixture[0]))
def test_cached_global_fixture_user_id(self):
sandwich = self.make_data_type("sandwich", is_global=True)
self.make_data_item(sandwich, "7.39")
frank = self.user.to_ota_restore_user()
sammy = CommCareUser.create(self.domain, 'sammy',
'***').to_ota_restore_user()
fixtures = call_fixture_generator(fixturegenerators.item_lists, frank)
self.assertEqual({item.attrib['user_id']
for item in fixtures}, {frank.user_id})
self.assertTrue(get_blob_db().exists(self.domain, FIXTURE_BUCKET))
bytes_ = six.binary_type
fixtures = [
ElementTree.fromstring(f) if isinstance(f, bytes_) else f for f in
call_fixture_generator(fixturegenerators.item_lists, sammy)
]
self.assertEqual({item.attrib['user_id']
for item in fixtures}, {sammy.user_id})
def test_location_fixture_generator_no_user_location(self):
"""
Ensures that a user without a location will still receive an empty fixture
"""
self.user.unset_location()
self.addCleanup(self.user.set_location, self.loc)
fixture = call_fixture_generator(location_fixture_generator, self.user.to_ota_restore_user())
self.assertEqual(len(fixture), 1)
self.assertEquals(len(fixture[0].findall('.//state')), 0)
def _assert_fixture_matches_file(self, xml_name, desired_locations, flat=False, related=False):
if flat:
generator = flat_location_fixture_generator
elif related:
generator = related_locations_fixture_generator
else:
generator = location_fixture_generator
fixture = ElementTree.tostring(call_fixture_generator(generator, self.user)[-1])
desired_fixture = self._assemble_expected_fixture(xml_name, desired_locations)
self.assertXmlEqual(desired_fixture, fixture)
def test_metadata_added_to_all_nodes(self):
mass = self.locations['Massachusetts']
self.user._couch_user.set_location(mass)
fixture = call_fixture_generator(flat_location_fixture_generator, self.user)[1] # first node is index
location_nodes = fixture.findall('locations/location')
self.assertEqual(7, len(location_nodes))
for location_node in location_nodes:
location_data_nodes = [child for child in location_node.find('location_data')]
self.assertEqual(2, len(location_data_nodes))
tags = {n.tag for n in location_data_nodes}
self.assertItemsEqual(tags, self.field_slugs)
def test_metadata_added_to_all_nodes(self):
mass = self.locations['Massachusetts']
self.user._couch_user.set_location(mass)
fixture = call_fixture_generator(flat_location_fixture_generator, self.user)[1] # first node is index
location_nodes = fixture.findall('locations/location')
self.assertEqual(7, len(location_nodes))
for location_node in location_nodes:
location_data_nodes = [child for child in location_node.find('location_data')]
self.assertEqual(2, len(location_data_nodes))
tags = {n.tag for n in location_data_nodes}
self.assertItemsEqual(tags, self.field_slugs)
def test_report_fixtures_provider_with_app(self):
"""
ReportFixturesProvider should not iterate all apps if app given
"""
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
with patch.object(ConfigurableReportDataSource, 'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
with mock_datasource_config():
fixtures = call_fixture_generator(report_fixture_generator, self.user, app=self.app1)
reports = fixtures[0].findall('.//report')
self.assertEqual(len(reports), 1)
self.assertEqual(reports[0].attrib.get('id'), '123456')
def test_empty_user_data_types(self):
self.make_data_type("cookie", is_global=False)
fixtures = call_fixture_generator(fixturegenerators.item_lists,
self.user.to_ota_restore_user())
# make sure each fixture is there, and only once
self.assertEqual(
[item.attrib['id'] for item in fixtures],
[
'item-list:cookie-index',
'item-list:district',
],
)
def test_report_fixtures_provider_with_app(self):
"""
ReportFixturesProvider should not iterate all apps if app given
"""
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
with patch.object(ConfigurableReportDataSource, 'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
with mock_sql_backend():
with mock_datasource_config():
fixtures = call_fixture_generator(report_fixture_generator, self.user, app=self.app1)
reports = fixtures[0].findall('.//report')
self.assertEqual(len(reports), 1)
self.assertEqual(reports[0].attrib.get('id'), '123456')
def test_fixture_provider_no_permission(self, _get_permission_checker):
_get_permission_checker().can_view_registry_data.return_value = False
fixtures = call_fixture_generator(registry_fixture_generator,
self.restore_user,
project=self.domain_obj)
self.assertEqual(1, len(fixtures))
expected_list_fixture = """
<fixture id="registry:list">
<registry_list></registry_list>
</fixture>"""
self.assertXmlEqual(
expected_list_fixture,
ElementTree.tostring(fixtures[0], encoding='utf-8'))
def test_include_without_expanding_includes_all_ancestors(self):
self.user._couch_user.set_location(self.locations['DTO'])
location_type = self.locations['DTO'].location_type
location_type.include_without_expanding = self.locations['DTO'].location_type
location_type.save()
fixture = ElementTree.tostring(call_fixture_generator(flat_location_fixture_generator, self.user)[-1])
for location_name in ('CDST1', 'CDST', 'DRTB1', 'DRTB', 'DTO1', 'DTO', 'CTO', 'CTO1', 'CTD'):
self.assertTrue(location_name in fixture)
for location_name in ('PHI1', 'TU1', 'DMC1'):
self.assertFalse(location_name in fixture)
def test_include_without_expanding_includes_all_ancestors(self):
self.user._couch_user.set_location(self.locations['DTO'])
location_type = self.locations['DTO'].location_type
location_type.include_without_expanding = self.locations['DTO'].location_type
location_type.save()
fixture = ElementTree.tostring(call_fixture_generator(flat_location_fixture_generator, self.user)[-1]).decode('utf-8')
for location_name in ('CDST1', 'CDST', 'DRTB1', 'DRTB', 'DTO1', 'DTO', 'CTO', 'CTO1', 'CTD'):
self.assertTrue(location_name in fixture)
for location_name in ('PHI1', 'TU1', 'DMC1'):
self.assertFalse(location_name in fixture)
def test_callcenter_fixture_commcare_user(self):
user = CommCareUser(_id='123', username="******")
indicator_set = MockIndicatorSet(name='test', indicators=OrderedDict([
('user_case1', {'i1': 1, 'i2': 2}),
('user_case2', {'i1': 0, 'i2': 3})
]))
restore_user = type('OTARestoreCommCareUserFake' if six.PY3 else b'OTARestoreCommCareUserFake', (OTARestoreCommCareUser,), {
'project': Domain(name='test', default_timezone='UTC'),
'get_call_center_indicators': lambda self, config: indicator_set,
})('test', user)
fixture, = call_fixture_generator(mock_indicators_fixture_generator, restore_user)
check_xml_line_by_line(
self, ElementTree.tostring(fixture),
ElementTree.tostring(gen_fixture(restore_user, indicator_set)))
def test_program_fixture(self):
user = self.user
Program(
domain=user.domain,
name="test1",
code="t1"
).save()
program_list = Program.by_domain(user.domain)
program_xml = self.generate_program_xml(program_list, user)
fixture = call_fixture_generator(program_fixture_generator, user)
self.assertXmlEqual(
program_xml,
ElementTree.tostring(fixture[0])
)
def test_additional_metadata_not_included(self):
mass = self.locations['Massachusetts']
mass.metadata = {'driver_friendliness': 'poor'}
mass.save()
def _clear_metadata():
mass.metadata = {}
mass.save()
self.addCleanup(_clear_metadata)
self.user._couch_user.set_location(mass)
fixture = call_fixture_generator(flat_location_fixture_generator, self.user)[1] # first node is index
mass_data = [
field for field in fixture.find('locations/location[@id="{}"]/location_data'.format(mass.location_id))
]
self.assertEqual(2, len(mass_data))
self.assertItemsEqual(self.field_slugs, [f.tag for f in mass_data])
def test_product_fixture(self):
user = self.user
fixture_xml = self.generate_product_fixture_xml(user)
index_schema, fixture = call_fixture_generator(product_fixture_generator, user)
self.assertXmlEqual(fixture_xml, ElementTree.tostring(fixture))
schema_xml = """
<schema id="commtrack:products">
<indices>
<index>@id</index>
<index>category</index>
<index>code</index>
<index>program_id</index>
</indices>
</schema>
"""
self.assertXmlEqual(schema_xml, ElementTree.tostring(index_schema))
def test_index_location_fixtures(self):
self.user._couch_user.set_location(self.locations['Massachusetts'])
expected_result = self._assemble_expected_fixture(
'index_location_fixtures',
['Massachusetts', 'Suffolk', 'Boston', 'Revere', 'Middlesex', 'Cambridge', 'Somerville'],
)
fixture_nodes = call_fixture_generator(flat_location_fixture_generator, self.user)
self.assertEqual(len(fixture_nodes), 2) # fixture schema, then fixture
# check the fixture like usual
fixture = extract_xml_partial(ElementTree.tostring(fixture_nodes[1]), '.')
expected_fixture = extract_xml_partial(expected_result, './fixture')
self.assertXmlEqual(expected_fixture, fixture)
# check the schema
schema = extract_xml_partial(ElementTree.tostring(fixture_nodes[0]), '.')
expected_schema = extract_xml_partial(expected_result, './schema')
self.assertXmlEqual(expected_schema, schema)
def test_existing_metadata_works(self):
mass = self.locations['Massachusetts']
mass.metadata = {'baseball_team': 'Red Sox'}
mass.save()
def _clear_metadata():
mass.metadata = {}
mass.save()
self.addCleanup(_clear_metadata)
self.user._couch_user.set_location(mass)
fixture = call_fixture_generator(flat_location_fixture_generator, self.user)[1] # first node is index
self.assertEqual(
'Red Sox',
fixture.find(
'locations/location[@id="{}"]/location_data/baseball_team'.format(mass.location_id)
).text
)
def test_report_fixtures_provider_with_app_that_doesnt_have_reports(self):
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
with patch.object(ConfigurableReportDataSource, 'get_data') as get_data_mock:
get_data_mock.return_value = self.rows
fixtures = call_fixture_generator(report_fixture_generator, self.user, app=self.app3)
self.assertEqual(len(fixtures), 0)
def setUpClass(cls):
super(ReportFiltersSuiteTest, cls).setUpClass()
delete_all_users()
cls.report_id = '7b97e8b53d00d43ca126b10093215a9d'
cls.report_config_mobile_id = 'a98c812873986df34fd1b4ceb45e6164ae9cc664'
cls.domain = 'report-filter-test-domain'
create_domain(cls.domain)
cls.user = create_restore_user(
domain=cls.domain,
username='******',
)
MOBILE_UCR.set(cls.domain, True, NAMESPACE_DOMAIN)
report_configuration = cls.make_report_config(cls.domain, cls.report_id)
# also make a report with a hidden column
cls.hidden_column_report_id = 'bd2a43018ad9463682165c1bc16347ac'
cls.hidden_column_mobile_id = '45152061d8dc4d2a8d987a0568abe1ae'
report_configuration_with_hidden_column = MAKE_REPORT_CONFIG(
cls.domain,
cls.hidden_column_report_id,
columns=[
FieldColumn(
type='field',
aggregation="simple",
column_id="color_94ec39e6",
display="color",
field="color_94ec39e6"
).to_json(),
FieldColumn(
type='field',
aggregation="simple",
column_id="hidden_color_94ec39e6",
display="color",
field="color_94ec39e6",
visible=False,
).to_json(),
]
)
cls.report_configs_by_id = {
cls.report_id: report_configuration,
cls.hidden_column_report_id: report_configuration_with_hidden_column
}
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=OrderedDict([
('fav_fruit_abc123_1', MobileSelectFilter()),
('computed_owner_name_40cc88a0_1', MobileSelectFilter()),
]),
uuid=cls.report_config_mobile_id,
)
)
module.report_configs.append(
ReportAppConfig(
report_id=cls.hidden_column_report_id,
header={},
description="",
complete_graph_configs={},
filters={},
uuid=cls.hidden_column_mobile_id,
)
)
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_datasource_config():
fixture, = call_fixture_generator(report_fixture_generator, cls.user)
cls.fixture = ElementTree.tostring(fixture)
def test_force_empty_when_user_has_no_locations(self, *args):
sync_log = SyncLog(date=datetime.utcnow())
# no relations have been touched since this synclog, but it still pushes down the empty list
self.assertEquals(
len(call_fixture_generator(related_locations_fixture_generator, self.user, last_sync=sync_log)), 2)
def test_no_user_locations_returns_empty(self):
empty_fixture = EMPTY_LOCATION_FIXTURE_TEMPLATE.format(self.user.user_id)
fixture = ElementTree.tostring(call_fixture_generator(location_fixture_generator, self.user)[0])
self.assertXmlEqual(empty_fixture, fixture)
