def create_remote_report_link(self, in_data):
linked_domain = in_data['linked_domain']
master_domain = in_data['master_domain'].strip('/').split('/')[-1]
report_id = in_data['report_id']
link = DomainLink.objects.filter(
remote_base_url__isnull=False,
linked_domain=linked_domain,
master_domain=master_domain,
).first()
if link:
create_linked_ucr(link, report_id)
return {'success': True}
else:
return {'success': False}
def test_linking_second_report_creates_single_datasource(self):
create_linked_ucr(self.domain_link, self.report.get_id)
new_report = get_sample_report_config()
new_report.title = "Another Report"
new_report.config_id = self.data_source.get_id
new_report.domain = self.domain
new_report.save()
create_linked_ucr(self.domain_link, new_report.get_id)
self.assertEqual(2, len(ReportConfiguration.by_domain(self.domain_link.linked_domain)))
self.assertItemsEqual(
[self.report.title, new_report.title],
[r.title for r in ReportConfiguration.by_domain(self.domain_link.linked_domain)],
)
def test_linked_reports_updated_for_remote(self, fake_ucr_getter):
old_remote_base_url = self.domain_link.remote_base_url
self.domain_link.remote_base_url = "http://my/app"
self.delete_modules(self.master1)
master_report, master_data_source = self._create_report_and_datasource(
)
# Update app before linking report, should throw an error
with self.assertRaises(AppLinkError):
updated_app = update_linked_app(self.linked_app, self.master1,
'a-user-id')
# Link report, then pull app
fake_ucr_getter.return_value = {
"report": master_report,
"datasource": master_data_source,
}
link_info = create_linked_ucr(self.domain_link, master_report.get_id)
updated_app = update_linked_app(self.linked_app, self.master1,
'a-user-id')
# report config added with the linked report id updated in report config
self.assertEqual(updated_app.modules[0].report_configs[0].report_id,
link_info.report.get_id)
# reset for other tests
self.domain_link.remote_base_url = old_remote_base_url
def test_linked_app_filter_maps_correctly(self):
linked_app = link_app(self.linked_app, self.domain,
self.master1.get_id)
self.data_source.configured_filter = {
"type":
"and",
"filters": [{
"type": "boolean_expression",
"operator": "eq",
"expression": {
"type": "property_name",
"property_name": "xmlns",
"datatype": None
},
"property_value":
"http://openrosa.org/formdesigner/1A255365-DAA1-4815-906D-CBD8D3A462B1",
"comment": None
}, {
"type": "boolean_expression",
"operator": "eq",
"expression": {
"type": "property_name",
"property_name": "app_id",
"datatype": None
},
"property_value": self.master1.get_id,
"comment": None
}]
}
self.data_source.save()
linked_report_info = create_linked_ucr(self.domain_link,
self.report.get_id)
self.assertEqual(
linked_report_info.datasource.configured_filter['filters'][1]
['property_value'], linked_app.get_id)
def test_remote_link_ucr(self, fake_ucr_getter):
create_domain(self.domain)
self.addCleanup(delete_all_domains)
couch_user = WebUser.create(self.domain, "test", "foobar", None, None)
django_user = couch_user.get_django_user()
self.addCleanup(delete_all_users)
api_key, _ = HQApiKey.objects.get_or_create(user=django_user)
auth_headers = {'HTTP_AUTHORIZATION': 'apikey test:%s' % api_key.key}
self.domain_link.save()
url = reverse('linked_domain:ucr_config', args=[self.domain, self.report.get_id])
headers = auth_headers.copy()
headers[REMOTE_REQUESTER_HEADER] = self.domain_link.linked_domain
resp = self.client.get(url, **headers)
fake_ucr_getter.return_value = json.loads(resp.content)
# Create
linked_report_info = create_linked_ucr(self.domain_link, self.report.get_id)
self.assertEqual(1, len(ReportConfiguration.by_domain(self.domain_link.linked_domain)))
self.assertEqual(self.report.get_id, linked_report_info.report.report_meta.master_id)
# Update
self.report.title = "Another new title"
self.report.save()
update_linked_ucr(self.domain_link, linked_report_info.report.get_id)
report = ReportConfiguration.get(linked_report_info.report.get_id)
self.assertEqual("Another new title", report.title)
def test_linked_reports_updated(self):
# add a report on the master app
master_data_source = get_sample_data_source()
master_data_source.domain = self.domain
master_data_source.save()
master_report = get_sample_report_config()
master_report.config_id = master_data_source.get_id
master_report.domain = self.domain
master_report.save()
master_reports_module = self.master1.add_module(
ReportModule.new_module('Reports', None))
master_reports_module.report_configs = [
ReportAppConfig(report_id=master_report.get_id,
header={'en': 'CommBugz'}),
]
# link report on master app to linked domain
link_info = create_linked_ucr(self.domain_link, master_report.get_id)
updated_app = update_linked_app(self.linked_app, self.master1,
'a-user-id')
# report config added with the linked report id updated in report config
self.assertEqual(updated_app.modules[0].report_configs[0].report_id,
link_info.report.get_id)
def test_link_creates_datasource_and_report(self):
link_info = create_linked_ucr(self.domain_link, self.report.get_id)
new_datasource = DataSourceConfiguration.get(link_info.datasource.get_id)
self.assertEqual(new_datasource.domain, self.domain_link.linked_domain)
new_report = ReportConfiguration.get(link_info.report.get_id)
self.assertEqual(new_report.domain, self.domain_link.linked_domain)
self.assertEqual(self.report.get_id, new_report.report_meta.master_id)
def test_delete_master_deletes_linked(self):
linked_report_info = create_linked_ucr(self.domain_link, self.report.get_id)
soft_delete(self.report)
update_linked_ucr(self.domain_link, linked_report_info.report.get_id)
report = ReportConfiguration.get(linked_report_info.report.get_id)
self.assertTrue(is_deleted(report))
self.report.config.deactivate()
update_linked_ucr(self.domain_link, linked_report_info.report.get_id)
report = ReportConfiguration.get(linked_report_info.report.get_id)
self.assertTrue(report.config.is_deactivated)
def test_update_ucr(self):
linked_report_info = create_linked_ucr(self.domain_link, self.report.get_id)
self.report.title = "New title"
self.report.save()
update_linked_ucr(self.domain_link, linked_report_info.report.get_id)
report = ReportConfiguration.get(linked_report_info.report.get_id)
self.assertEqual("New title", report.title)
self.assertEqual(self.report.get_id, report.report_meta.master_id)
self.assertNotEqual(self.report.config_id, report.config_id)
def test_linked_reports_updated(self):
# add a report on the master app
self.delete_modules(self.master1)
master_report, master_data_source = self._create_report_and_datasource(
)
# link report on master app to linked domain
link_info = create_linked_ucr(self.domain_link, master_report.get_id)
updated_app = update_linked_app(self.linked_app, self.master1,
'a-user-id')
# report config added with the linked report id updated in report config
self.assertEqual(updated_app.modules[0].report_configs[0].report_id,
link_info.report.get_id)
def _release_report(self, domain_link, model, user_id):
report_id = model['detail']['report_id']
linked_report = get_downstream_report(domain_link.linked_domain,
report_id)
if not linked_report:
try:
linked_report_info = create_linked_ucr(domain_link, report_id)
linked_report = linked_report_info.report
except DomainLinkError as e:
return self._error_tuple(str(e))
# have no hit an error case, so update the ucr
update_linked_ucr(domain_link, linked_report.get_id)
domain_link.update_last_pull(
MODEL_REPORT,
user_id,
model_detail=ReportLinkDetail(
report_id=linked_report.get_id).to_json(),
)
def test_remote_link_ucr(self, fake_ucr_getter):
fake_ucr_getter.return_value = {
"report": self.report,
"datasource": self.data_source,
}
# Create
linked_report_info = create_linked_ucr(self.domain_link,
self.report.get_id)
self.assertEqual(
1,
len(ReportConfiguration.by_domain(self.domain_link.linked_domain)))
self.assertEqual(self.report.get_id,
linked_report_info.report.report_meta.master_id)
# Update
self.report.title = "Another new title"
self.report.save()
update_linked_ucr(self.domain_link, linked_report_info.report.get_id)
report = ReportConfiguration.get(linked_report_info.report.get_id)
self.assertEqual("Another new title", report.title)
def test_already_linked_report_is_pushed(self):
new_report = self._create_new_report()
new_report.title = "Title"
new_report.save()
self.addCleanup(new_report.delete)
linked_report_info = create_linked_ucr(self.domain_link,
new_report.get_id)
self.addCleanup(linked_report_info.report.delete)
# after creating the link, update the upstream report
new_report.title = "Updated Title"
new_report.save()
model = self._linked_data_view_model(
MODEL_REPORT,
detail=ReportLinkDetail(report_id=new_report.get_id).to_json())
manager = ReleaseManager(self.domain, self.user.username)
errors = manager._release_report(self.domain_link, model, 'test-user')
self.assertIsNone(errors)
downstream_report = get_downstream_report(self.linked_domain,
new_report.get_id)
self.assertIsNotNone(downstream_report)
self.assertEqual("Updated Title", downstream_report.title)
