def test_get_latest_master_release_not_permitted(self):
self.linked_app.master = self.plain_master_app.get_id
release = self.plain_master_app.make_build()
release.is_released = True
release.save()
self.addCleanup(release.delete)
latest_master_release = self.linked_app.get_latest_master_release()
self.assertEqual(release.get_id, latest_master_release.get_id)
self.domain_link.linked_domain = 'other'
self.domain_link.save()
get_domain_master_link.clear('domain-2')
def _revert():
self.domain_link.linked_domain = 'domain-2'
self.domain_link.save()
self.addCleanup(_revert)
with self.assertRaises(ActionNotPermitted):
# re-fetch to bust memoize cache
LinkedApplication.get(
self.linked_app._id).get_latest_master_release()
def test_update_from_specific_build(self, *args):
master_app = Application.new_app(self.domain, "Master Application")
master_app.linked_whitelist = [self.linked_domain]
master_app.save()
self.addCleanup(master_app.delete)
linked_app = LinkedApplication.new_app(self.linked_domain,
"Linked Application")
linked_app.master = master_app.get_id
linked_app.save()
self.addCleanup(linked_app.delete)
master_app.add_module(Module.new_module('M1', None))
copy1 = self._make_build(master_app, True)
master_app.add_module(Module.new_module('M2', None))
master_app.save() # increment version number
self._make_build(master_app, True)
update_linked_app(linked_app,
'test_update_from_specific_build',
master_build=copy1)
linked_app = LinkedApplication.get(linked_app._id)
self.assertEqual(len(linked_app.modules), 1)
self.assertEqual(linked_app.version, copy1.version)
def test_unlink_apps_for_domain_processes_multiple_apps(self):
linked_app1 = LinkedApplication.new_app(self.domain, 'Linked1')
linked_app2 = LinkedApplication.new_app(self.domain, 'Linked2')
linked_app1.save()
linked_app2.save()
unlinked_apps = unlink_apps_in_domain(self.domain)
for app in unlinked_apps:
self.addCleanup(app.delete)
self.assertEqual(2, len(unlinked_apps))
def test_get_linked_apps_for_domain(self):
linked_app1 = LinkedApplication.new_app('domain', 'One')
linked_app2 = LinkedApplication.new_app('domain', 'Two')
linked_app1.save()
linked_app2.save()
self.addCleanup(linked_app1.delete)
self.addCleanup(linked_app2.delete)
linked_apps = get_linked_apps_for_domain('domain')
linked_app_ids = [app._id for app in linked_apps]
self.assertEqual([linked_app1._id, linked_app2._id], linked_app_ids)
def _pop_deprecated_field(apps, schema_editor):
app_ids = (get_doc_ids_by_class(LinkedApplication) +
get_deleted_doc_ids_by_class(LinkedApplication))
iter_update(LinkedApplication.get_db(),
_pop_field,
with_progress_bar(app_ids),
chunksize=1)
def create_linked_app(master_domain, master_id, target_domain, target_name, remote_details=None):
from corehq.apps.app_manager.models import LinkedApplication
linked_app = LinkedApplication(
name=target_name,
domain=target_domain,
)
return link_app(linked_app, master_domain, master_id, remote_details)
def handle(self,
domain=None,
app_id=None,
dry_run=False,
ignore_deleted=False,
verbose=False,
**options):
self.dry_run = dry_run
if verbose:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.ERROR)
if domain and app_id:
app = get_app(
domain,
app_id) # Sanity check, will 404 if domain doesn't match
assert (app.doc_type == 'LinkedApplication'
or app.doc_type == 'LinkedApplication-Deleted')
app_ids = set([
v.build_id
for v in get_all_built_app_ids_and_versions(domain, app_id)
])
app_ids.add(app_id) # in case linked app has no builds yet
else:
app_ids = get_doc_ids_by_class(LinkedApplication)
if not ignore_deleted:
app_ids += get_deleted_doc_ids_by_class(LinkedApplication)
iter_update(LinkedApplication.get_db(),
self._add_overrides_for_build,
with_progress_bar(app_ids),
chunksize=1)
def setUpClass(cls):
super(TestGetDataModels, cls).setUpClass()
cls.upstream_domain_obj = create_domain('upstream-domain')
cls.upstream_domain = cls.upstream_domain_obj.name
cls.downstream_domain_obj = create_domain('downstream-domain')
cls.downstream_domain = cls.downstream_domain_obj.name
cls.original_app = Application.new_app(cls.upstream_domain,
"Original Application")
cls.original_app.linked_whitelist = [cls.downstream_domain]
cls.original_app.save()
cls.linked_app = LinkedApplication.new_app(cls.downstream_domain,
"Linked Application")
cls.linked_app.upstream_app_id = cls.original_app._id
cls.linked_app.save()
cls.original_report = _create_report(cls.upstream_domain)
cls.linked_report = _create_report(cls.downstream_domain,
upstream_id=cls.original_report._id)
cls.original_keyword = _create_keyword(cls.upstream_domain)
cls.linked_keyword = _create_keyword(
cls.downstream_domain, upstream_id=cls.original_keyword.id)
cls.original_fixture = _create_fixture(cls.upstream_domain)
cls.domain_link = DomainLink.link_domains(cls.downstream_domain,
cls.upstream_domain)
def test_override_translations(self):
translations = {'en': {'updates.check.begin': 'update?'}}
self.linked_app.master = self.plain_master_app.get_id
copy = self.plain_master_app.make_build()
copy.save()
self.addCleanup(copy.delete)
self.plain_master_app.save() # increment version number
copy1 = self.plain_master_app.make_build()
copy1.is_released = True
copy1.save()
self.addCleanup(copy1.delete)
self.linked_app.linked_app_translations = translations
self.linked_app.save()
self.assertEqual(self.linked_app.translations, {})
update_linked_app(self.linked_app, 'test_override_translations')
# fetch after update to get the new version
self.linked_app = LinkedApplication.get(self.linked_app._id)
self.assertEqual(self.plain_master_app.translations, {})
self.assertEqual(self.linked_app.linked_app_translations, translations)
self.assertEqual(self.linked_app.translations, translations)
def _migrate_linked_apps(apps, schema_editor):
app_db = LinkedApplication.get_db()
linked_apps = get_all_docs_with_doc_types(
app_db, ['LinkedApplication', 'LinkedApplication-Deleted']
)
errors = []
for app_doc in linked_apps:
remote_details = None
remote_url = app_doc.pop('remote_url_base', None)
if remote_url:
auth = app_doc.pop('remote_auth', {})
remote_details = RemoteLinkDetails(
remote_url,
auth.get('username'),
auth.get('api_key'),
)
master_domain = app_doc.pop('master_domain', None)
if not master_domain and not remote_url:
master_domain = get_app(None, app_doc['master']).domain
try:
DomainLink.link_domains(app_doc['domain'], master_domain, remote_details)
except DomainLinkError as e:
errors.append(str(e))
else:
app_db.save_doc(app_doc)
_assert = soft_assert('{}@dimagi.com'.format('skelly'), exponential_backoff=False)
_assert(not errors, 'Errors migrating linked apps to linked domain', {
'errors': errors
})
def test_override_translations(self):
translations = {'en': {'updates.check.begin': 'update?'}}
self.linked_app.master = self.plain_master_app.get_id
copy = self.plain_master_app.make_build()
copy.save()
self.addCleanup(copy.delete)
self.plain_master_app.save() # increment version number
copy1 = self.plain_master_app.make_build()
copy1.is_released = True
copy1.save()
self.addCleanup(copy1.delete)
self.linked_app.linked_app_translations = translations
self.linked_app.save()
self.assertEqual(self.linked_app.translations, {})
update_linked_app(self.linked_app, 'test_override_translations')
# fetch after update to get the new version
self.linked_app = LinkedApplication.get(self.linked_app._id)
self.assertEqual(self.plain_master_app.translations, {})
self.assertEqual(self.linked_app.linked_app_translations, translations)
self.assertEqual(self.linked_app.translations, translations)
def setUpClass(cls):
super(TestAddAppIdToLinkedReports, cls).setUpClass()
cls.upstream_domain_obj = create_domain('test-upstream')
cls.upstream_domain = cls.upstream_domain_obj.name
cls.downstream_domain_obj = create_domain('test-downstream')
cls.downstream_domain = cls.downstream_domain_obj.name
cls.domain_link = DomainLink.link_domains(cls.downstream_domain,
cls.upstream_domain)
cls.original_app = Application.new_app(cls.upstream_domain,
"Original Application")
cls.original_app.linked_whitelist = [cls.downstream_domain]
cls.original_app.save()
cls.linked_app = LinkedApplication.new_app(cls.downstream_domain,
"Linked Application")
cls.linked_app.upstream_app_id = cls.original_app._id
cls.linked_app.family_id = cls.original_app._id
cls.linked_app.save()
cls.original_report = _create_report(cls.upstream_domain,
app_id=cls.original_app._id)
# intentionally do not pass app_id into create method, as this is the scenario this migration is used in
cls.linked_report = _create_report(cls.downstream_domain,
upstream_id=cls.original_report._id)
def _make_linked_app(self, upstream_domain):
linked_app = LinkedApplication.new_app('downstream', "Linked Application")
linked_app.save()
domain_link = DomainLink.link_domains('downstream', upstream_domain)
self.addCleanup(linked_app.delete)
self.addCleanup(domain_link.delete)
return linked_app
def setUpClass(cls):
super(BaseLinkedAppsTest, cls).setUpClass()
cls.domain_obj = create_domain('domain')
cls.domain = cls.domain_obj.name
cls.master_app_with_report_modules = Application.new_app(
cls.domain, "Master Application")
module = cls.master_app_with_report_modules.add_module(
ReportModule.new_module('Reports', None))
module.report_configs = [
ReportAppConfig(report_id='master_report_id',
header={'en': 'CommBugz'}),
]
cls.linked_domain_obj = create_domain('domain-2')
cls.linked_domain = cls.linked_domain_obj.name
cls.master1 = Application.new_app(cls.domain,
"First Master Application")
cls.master1.save()
cls.master2 = Application.new_app(cls.domain,
"Second Master Application")
cls.master2.save()
cls.linked_app = LinkedApplication.new_app(cls.linked_domain,
"Linked Application")
cls.linked_app.family_id = cls.master1._id
cls.linked_app.save()
cls.domain_link = DomainLink.link_domains(cls.linked_domain,
cls.domain)
def handle(self, master_id, linked_id, url_base, domain, username, api_key, **options):
remote_details = RemoteLinkDetails(
url_base,
username,
api_key,
)
linked_app = LinkedApplication.get(linked_id)
link_app(linked_app, domain, master_id, remote_details)
def test_app_build_and_release(self, *args):
self._make_master1_build(True)
original_version = self.linked_app.version
self.manager.release([
self._model_status(MODEL_APP, detail=AppLinkDetail(app_id=self.master1._id).to_json()),
], [self.linked_domain], True)
self._assert_domain_outcomes({self.linked_domain}, set())
self.linked_application = LinkedApplication.get(self.linked_app._id)
self.assertEqual(original_version + 1, self.linked_application.version)
self.assertTrue(self.linked_application.is_released)
def test_unlink_app_returns_regular_app_if_linked(self):
linked_app = LinkedApplication.new_app(self.domain, 'Linked Application')
linked_app.save()
expected_app_id = linked_app._id
unlinked_app = unlink_app(linked_app)
self.addCleanup(unlinked_app.delete)
# ensure new app is not linked, and converted properly
self.assertEqual('Application', unlinked_app.get_doc_type())
self.assertEqual(expected_app_id, unlinked_app._id)
def test_override_logo(self):
image_data = _get_image_data()
image = CommCareImage.get_by_data(image_data)
image.attach_data(image_data, original_filename='logo.png')
image.add_domain(self.linked_app.domain)
image.save()
self.addCleanup(image.delete)
image_path = "jr://file/commcare/logo/data/hq_logo_android_home.png"
logo_refs = {
"hq_logo_android_home": {
"humanized_content_length": "45.4 KB",
"icon_class": "fa fa-picture-o",
"image_size": "448 X 332 Pixels",
"m_id": image._id,
"media_type": "Image",
"path": "jr://file/commcare/logo/data/hq_logo_android_home.png",
"uid": "3b79a76a067baf6a23a0b6978b2fb352",
"updated": False,
"url": "/hq/multimedia/file/CommCareImage/e3c45dd61c5593fdc5d985f0b99f6199/"
},
}
self.linked_app.master = self.plain_master_app.get_id
copy = self.plain_master_app.make_build()
copy.save()
self.addCleanup(copy.delete)
self.plain_master_app.save() # increment version number
copy1 = self.plain_master_app.make_build()
copy1.is_released = True
copy1.save()
self.addCleanup(copy1.delete)
self.linked_app.version = 1
self.linked_app.linked_app_logo_refs = logo_refs
self.linked_app.create_mapping(image, image_path, save=False)
self.linked_app.save()
self.assertEqual(self.linked_app.logo_refs, {})
update_linked_app(self.linked_app, 'test_override_logos')
# fetch after update to get the new version
self.linked_app = LinkedApplication.get(self.linked_app._id)
self.assertEqual(self.plain_master_app.logo_refs, {})
self.assertEqual(self.linked_app.linked_app_logo_refs, logo_refs)
self.assertEqual(self.linked_app.logo_refs, logo_refs)
# cleanup the linked app logo properties
self.linked_app.linked_app_logo_refs = {}
self.linked_app.save()
def setUp(self):
super(TestBulkUiTranslation, self).setUp()
self.app = Application.new_app("test-domain", "Test App")
self.app.langs = ["en", "fra"]
self.app.translations = INITIAL_TRANSLATIONS
self.linked_app = LinkedApplication.new_app('test-domain-2',
'Test Linked App')
self.linked_app.langs = ["en", "fra"]
self.linked_app.translations = INITIAL_TRANSLATIONS
self.linked_app.linked_app_translations = INITIAL_LINKED_APP_TRANSLATIONS
def test_app_build_and_release(self, *args):
self._make_master1_build(True)
original_version = self.linked_app.version
self._assert_release([
self._linked_data_view_model(
MODEL_APP,
detail=AppLinkDetail(app_id=self.master1._id).to_json()),
],
build_apps=True)
self.linked_application = LinkedApplication.get(self.linked_app._id)
self.assertEqual(original_version + 1, self.linked_application.version)
self.assertTrue(self.linked_application.is_released)
def test_unlink_apps_for_domain_successfully_unlinks_app(self):
linked_app = LinkedApplication.new_app(self.domain, 'Linked')
linked_app.save()
expected_app_id = linked_app._id
unlinked_apps = unlink_apps_in_domain(self.domain)
for app in unlinked_apps:
self.addCleanup(app.delete)
# ensure new app exists that is not linked
self.assertEqual('Application', unlinked_apps[0].get_doc_type())
self.assertEqual(expected_app_id, unlinked_apps[0]._id)
def test_overwrite_app_override_form_unique_ids(self):
module = self.master1.add_module(Module.new_module('M1', None))
master_form = module.new_form('f1', None, self.get_xml('very_simple_form').decode('utf-8'))
add_xform_resource_overrides(self.linked_domain, self.linked_app.get_id, {master_form.unique_id: '123'})
overwrite_app(self.linked_app, self.master1)
self.assertEqual(
{master_form.xmlns: '123'},
self._get_form_ids_by_xmlns(LinkedApplication.get(self.linked_app._id))
)
ResourceOverride.objects.filter(domain=self.linked_domain, app_id=self.linked_app.get_id).delete()
def test_overwrite_app_maintain_form_unique_ids(self):
module = self.master1.add_module(Module.new_module('M1', None))
module.new_form('f1', None, self.get_xml('very_simple_form').decode('utf-8'))
module = self.linked_app.add_module(Module.new_module('M1', None))
module.new_form('f1', None, self.get_xml('very_simple_form').decode('utf-8'))
id_map_before = _get_form_ids_by_xmlns(self.linked_app)
overwrite_app(self.linked_app, self.master1, {})
self.assertEqual(
id_map_before,
_get_form_ids_by_xmlns(LinkedApplication.get(self.linked_app._id))
)
def test_overwrite_app_maintain_ids(self):
module = self.plain_master_app.add_module(Module.new_module('M1', None))
module.new_form('f1', None, self.get_xml('very_simple_form').decode('utf-8'))
module = self.linked_app.add_module(Module.new_module('M1', None))
module.new_form('f1', None, self.get_xml('very_simple_form').decode('utf-8'))
id_map_before = _get_form_id_map(self.linked_app)
overwrite_app(self.linked_app, self.plain_master_app, {})
self.assertEqual(
id_map_before,
_get_form_id_map(LinkedApplication.get(self.linked_app._id))
)
def setUpClass(cls):
super(BaseLinkedAppsTest, cls).setUpClass()
cls.master_app_with_report_modules = Application.new_app('domain', "Master Application")
module = cls.master_app_with_report_modules.add_module(ReportModule.new_module('Reports', None))
module.report_configs = [
ReportAppConfig(report_id='id', header={'en': 'CommBugz'}),
]
cls.plain_master_app = Application.new_app('domain', "Master Application")
cls.plain_master_app.linked_whitelist = ['domain-2']
cls.plain_master_app.save()
cls.linked_app = LinkedApplication.new_app('domain-2', "Linked Application")
cls.linked_app.save()
def test_overwrite_app_override_form_unique_ids(self):
master_form = list(self.master1.get_forms(bare=True))[0]
add_xform_resource_overrides(self.linked_domain,
self.linked_app.get_id,
{master_form.unique_id: '123'})
overwrite_app(self.linked_app, self.master1)
self.assertEqual({master_form.xmlns: '123'},
self._get_form_ids_by_xmlns(
LinkedApplication.get(self.linked_app._id)))
ResourceOverride.objects.filter(
domain=self.linked_domain, app_id=self.linked_app.get_id).delete()
def test_unlink_apps_for_domain_only_processes_linked_apps(self):
app = Application.new_app(self.domain, 'Original')
linked_app = LinkedApplication.new_app(self.domain, 'Linked')
app.save()
self.addCleanup(app.delete)
linked_app.save()
expected_app_id = linked_app._id
unlinked_apps = unlink_apps_in_domain(self.domain)
for app in unlinked_apps:
self.addCleanup(app.delete)
self.assertEqual(1, len(unlinked_apps))
self.assertEqual(expected_app_id, unlinked_apps[0]._id)
def test_overwrite_app_maintain_ids(self):
module = self.plain_master_app.add_module(Module.new_module(
'M1', None))
module.new_form('f1', None, self.get_xml('very_simple_form'))
module = self.linked_app.add_module(Module.new_module('M1', None))
module.new_form('f1', None, self.get_xml('very_simple_form'))
id_map_before = _get_form_id_map(self.linked_app)
overwrite_app(self.linked_app, self.plain_master_app, {})
self.assertEqual(
id_map_before,
_get_form_id_map(LinkedApplication.get(self.linked_app._id)))
def test_update_from_specific_build(self, *args):
factory = AppFactory(self.domain, "Upstream Application")
m0, f0 = factory.new_basic_module("M1", None)
f0.source = get_simple_form()
master_app = factory.app
master_app.save()
self.addCleanup(master_app.delete)
linked_app = LinkedApplication.new_app(self.linked_domain,
"Linked Application")
linked_app.save()
self.addCleanup(linked_app.delete)
copy1 = self._make_build(master_app, True)
m1, f1 = factory.new_basic_module("M2", None)
f1.source = get_simple_form()
master_app.save() # increment version number
self._make_build(master_app, True)
update_linked_app(linked_app, copy1, 'test_update_from_specific_build')
linked_app = LinkedApplication.get(linked_app._id)
self.assertEqual(len(linked_app.modules), 1)
self.assertEqual(linked_app.version, copy1.version)
def test_override_translations(self, *args):
translations = {'en': {'updates.check.begin': 'update?'}}
self._make_master1_build(True)
self._make_master1_build(True)
self.linked_app.linked_app_translations = translations
self.linked_app.save()
self.assertEqual(self.linked_app.translations, {})
self._pull_linked_app(self.master1.get_id)
self.linked_app = LinkedApplication.get(self.linked_app._id)
self.assertEqual(self.master1.translations, {})
self.assertEqual(self.linked_app.linked_app_translations, translations)
self.assertEqual(self.linked_app.translations, translations)
def setUpClass(cls):
super(DBAccessorsTest, cls).setUpClass()
cls.project = Domain.get_or_create_with_name(cls.domain, is_active=True)
cls.first_saved_version = 2
cls.normal_app = Application.wrap(
Application(domain=cls.domain, name='foo', version=1, modules=[Module()]).to_json()
)
cls.normal_app.save()
cls.remote_app = RemoteApp.wrap(RemoteApp(domain=cls.domain, version=1, name='bar').to_json())
cls.remote_app.save()
cls.linked_app = LinkedApplication.wrap(
LinkedApplication(domain=cls.domain, version=1, name='linked-app', upstream_app_id='abc123').to_json()
)
cls.linked_app.save()
cls.decoy_apps = [
# this one is a build
Application(
domain=cls.domain,
copy_of=cls.normal_app.get_id,
version=cls.first_saved_version,
has_submissions=True,
),
# this one is another build
Application(domain=cls.domain, copy_of=cls.normal_app.get_id, version=12),
# this one is another app
Application(domain=cls.domain, copy_of='1234', version=12),
# this one is in the wrong domain
Application(domain='decoy-domain', version=5)
]
for app in cls.decoy_apps:
app.save()
def handle(self, master_id, linked_id, **options):
print("Linking apps")
master_app = Application.get(master_id)
master_version = get_latest_released_app_version(master_app.domain, master_id)
if not master_version:
raise CommandError(
"Creating linked app failed."
" Unable to get latest released version of your app."
" Make sure you have at least one released build."
)
linked_app = LinkedApplication.get(linked_id)
link_app(linked_app, master_app.domain, master_id)
update_linked_app(linked_app, 'system')
def handle(self, master_id, linked_id, **options):
print("Linking apps")
master_app = Application.get(master_id)
master_version = get_latest_released_app_version(master_app.domain, master_id)
if not master_version:
raise CommandError(
"Creating linked app failed."
" Unable to get latest released version of your app."
" Make sure you have at least one released build."
)
linked_app = LinkedApplication.get(linked_id)
link_app(linked_app, master_app.domain, master_id)
update_linked_app(linked_app, 'system')
def setup_linked_app(self, set_family_id=False, set_upstream_app_id=False):
original_app = Application.new_app(self.upstream_domain,
"Original Application")
original_app.save()
linked_app = LinkedApplication.new_app(self.downstream_domain,
"Linked Application")
if set_family_id:
linked_app.family_id = original_app._id
if set_upstream_app_id:
linked_app.upstream_app_id = original_app._id
linked_app.save()
self.addCleanup(original_app.delete)
self.addCleanup(linked_app.delete)
return original_app, linked_app
def test_get_latest_master_release_not_permitted(self):
self.linked_app.master = self.plain_master_app.get_id
release = self.plain_master_app.make_build()
release.is_released = True
release.save()
self.addCleanup(release.delete)
latest_master_release = self.linked_app.get_latest_master_release()
self.assertEqual(release.get_id, latest_master_release.get_id)
self.domain_link.linked_domain = 'other'
self.domain_link.save()
get_domain_master_link.clear('domain-2')
def _revert():
self.domain_link.linked_domain = 'domain-2'
self.domain_link.save()
self.addCleanup(_revert)
with self.assertRaises(ActionNotPermitted):
# re-fetch to bust memoize cache
LinkedApplication.get(self.linked_app._id).get_latest_master_release()
def setUpClass(cls):
super(BaseLinkedAppsTest, cls).setUpClass()
cls.domain = 'domain'
cls.master_app_with_report_modules = Application.new_app(cls.domain, "Master Application")
module = cls.master_app_with_report_modules.add_module(ReportModule.new_module('Reports', None))
module.report_configs = [
ReportAppConfig(report_id='master_report_id', header={'en': 'CommBugz'}),
]
cls.plain_master_app = Application.new_app(cls.domain, "Master Application")
cls.linked_domain = 'domain-2'
cls.plain_master_app.linked_whitelist = [cls.linked_domain]
cls.plain_master_app.save()
cls.linked_app = LinkedApplication.new_app(cls.linked_domain, "Linked Application")
cls.linked_app.save()
cls.domain_link = DomainLink.link_domains(cls.linked_domain, cls.domain)
def setUp(self):
# re-fetch app
self.linked_app = LinkedApplication.get(self.linked_app._id)
