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 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 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)