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 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 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 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 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 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_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_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_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 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 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 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
factory1 = AppFactory(self.domain,
"First Upstream Application",
include_xmlns=True)
m0_1, f0_1 = factory1.new_basic_module("M1", None)
f0_1.source = get_simple_form(f0_1.xmlns)
self.master1 = factory1.app
self.master1.save()
factory2 = AppFactory(self.domain,
"Second Upstream Application",
include_xmlns=True)
m0_2, f0_2 = factory2.new_basic_module("M2", None)
f0_2.source = get_simple_form(f0_2.xmlns)
self.master2 = factory2.app
self.master2.save()
self.linked_app = LinkedApplication.new_app(self.linked_domain,
"Linked Application")
self.linked_app.family_id = self.master1._id
self.linked_app.save()
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.master1 = Application.new_app(cls.domain, "Master Application")
cls.linked_domain = 'domain-2'
cls.master1.linked_whitelist = [cls.linked_domain]
cls.master1.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 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)
