def link_app(linked_app, master_domain, master_id, remote_details=None):
DomainLink.link_domains(linked_app.domain, master_domain, remote_details)
linked_app.master = master_id
linked_app.doc_type = 'LinkedApplication'
linked_app.save()
return linked_app
def test_link_new_master(self):
link = DomainLink.link_domains('linked', 'master')
link.deleted = True
link.save()
link1 = DomainLink.link_domains('linked', 'master1')
self.assertNotEqual(link.pk, link1.pk)
def handle(self, url_base, upstream_domain, username, api_key, downstream_domain, **options):
remote_details = RemoteLinkDetails(
url_base=url_base,
username=username,
api_key=api_key
)
DomainLink.link_domains(downstream_domain, upstream_domain, remote_details)
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 link_app(linked_app, master_domain, master_id, remote_details=None):
DomainLink.link_domains(linked_app.domain, master_domain, remote_details)
linked_app.master = master_id
linked_app.doc_type = 'LinkedApplication'
linked_app.save()
return linked_app
def test_link_previously_deleted(self):
link = DomainLink.link_domains('linked', 'master')
link.deleted = True
link.save()
link1 = DomainLink.link_domains('linked', 'master')
self.assertEqual(link.pk, link1.pk)
self.assertFalse(link1.deleted)
def test_link_deleted_then_create_existing_link(self):
# create a link and delete it
link = DomainLink.link_domains('linked', 'master')
link.deleted = True
link.save()
# create a new link
link1 = DomainLink.link_domains('linked', 'master1')
# create the same link again
link2 = DomainLink.link_domains('linked', 'master1')
self.assertEqual(link1.pk, link2.pk)
self.assertNotEqual(link.pk, link2.pk)
def test_link_deleted_then_create_existing_link(self):
# create a link and delete it
link = DomainLink.link_domains('linked', 'master')
link.deleted = True
link.save()
# create a new link
link1 = DomainLink.link_domains('linked', 'master1')
# create the same link again
link2 = DomainLink.link_domains('linked', 'master1')
self.assertEqual(link1.pk, link2.pk)
self.assertNotEqual(link.pk, link2.pk)
def link_app(linked_app, master_domain, master_id, remote_details=None):
DomainLink.link_domains(linked_app.domain, master_domain, remote_details)
linked_app.family_id = master_id
linked_app.doc_type = 'LinkedApplication'
linked_app.save()
if linked_app.master_is_remote:
try:
pull_missing_multimedia_for_app(linked_app)
except RemoteRequestError:
raise AppLinkError('Error fetching multimedia from remote server. Please try again later.')
return linked_app
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 setUpClass(cls):
super().setUpClass()
cls.user = WebUser.create(cls.domain, 'fiona', 'secret', None, None)
cls.manager = ReleaseManager(cls.domain, cls.user)
master1_module = cls.master1.add_module(Module.new_module('Module for master1', None))
master1_module.new_form('Form for master1', 'en', get_blank_form_xml('Form for master1'))
cls.extra_domain = 'antarctica'
cls.extra_domain_link = DomainLink.link_domains(cls.extra_domain, cls.domain)
def test_downstream_url(self):
domain_link = DomainLink.link_domains(
linked_domain=self.downstream.name,
master_domain=self.upstream.name)
self.addCleanup(domain_link.delete)
expected_downstream_url = '/a/downstream-domain/settings/project/domain_links/'
self.assertEqual(expected_downstream_url, domain_link.downstream_url)
def setUpClass(cls):
super().setUpClass()
cls.domain_obj = create_domain('domain')
cls.domain = cls.domain_obj.name
cls.linked_domain_obj = create_domain('domain-2')
cls.linked_domain = cls.linked_domain_obj.name
cls.domain_link = DomainLink.link_domains(cls.linked_domain,
cls.domain)
def test_remote_downstream_url(self):
domain_link = DomainLink.link_domains(
linked_domain=self.downstream.name,
master_domain=self.upstream.name)
domain_link.remote_base_url = 'test.base.url'
domain_link.save()
self.addCleanup(domain_link.delete)
expected_downstream_url = self.downstream.name # remote downstream urls are equal to the name
self.assertEqual(expected_downstream_url, domain_link.downstream_url)
def setUpClass(cls):
super(TestUpdateRolesRemote, cls).setUpClass()
cls.domain_obj = create_domain('domain')
cls.domain = cls.domain_obj.name
cls.linked_domain_obj = create_domain('domain-2')
cls.linked_domain = cls.linked_domain_obj.name
cls.domain_link = DomainLink.link_domains(cls.linked_domain,
cls.domain)
cls.domain_link.remote_base_url = "http://other.org"
cls.domain_link.save()
def setUpClass(cls):
super(TestGetDownstreamAppId, cls).setUpClass()
cls.upstream_domain_obj = create_domain('upstream')
cls.upstream_domain = cls.upstream_domain_obj.name
cls.upstream_domain_obj.save()
cls.downstream_domain_obj = create_domain('downstream')
cls.downstream_domain = cls.downstream_domain_obj.name
cls.downstream_domain_obj.save()
cls.domain_link = DomainLink.link_domains(cls.downstream_domain,
cls.upstream_domain)
cls.domain_link.save()
def setUpClass(cls):
super(RemoteAuthTest, cls).setUpClass()
cls.master_domain = uuid.uuid4().hex
cls.linked_domain = uuid.uuid4().hex
cls.domain = create_domain(cls.master_domain)
cls.couch_user = WebUser.create(cls.master_domain, "test", "foobar")
cls.django_user = cls.couch_user.get_django_user()
cls.api_key, _ = ApiKey.objects.get_or_create(user=cls.django_user)
cls.auth_headers = {'HTTP_AUTHORIZATION': 'apikey test:%s' % cls.api_key.key}
cls.linked_domain_requester = absolute_reverse('domain_homepage', args=[cls.linked_domain])
cls.domain_link = DomainLink.link_domains(cls.linked_domain_requester, cls.master_domain)
def setUpClass(cls):
super(RemoteAuthTest, cls).setUpClass()
cls.master_domain = uuid.uuid4().hex
cls.linked_domain = uuid.uuid4().hex
cls.domain = create_domain(cls.master_domain)
cls.couch_user = WebUser.create(cls.master_domain, "test", "foobar")
cls.django_user = cls.couch_user.get_django_user()
cls.api_key, _ = ApiKey.objects.get_or_create(user=cls.django_user)
cls.auth_headers = {'HTTP_AUTHORIZATION': 'apikey test:%s' % cls.api_key.key}
cls.linked_domain_requester = absolute_reverse('domain_homepage', args=[cls.linked_domain])
cls.domain_link = DomainLink.link_domains(cls.linked_domain_requester, cls.master_domain)
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()
cls.domain_link = DomainLink.link_domains('domain-2', 'domain')
def link_domains(couch_user, upstream_domain, downstream_domain):
if not domain_exists(downstream_domain):
error = gettext("The project space {} does not exist. Verify that the name is correct, and that the "
"domain has not been deleted.").format(downstream_domain)
raise DomainDoesNotExist(error)
if get_active_domain_link(upstream_domain, downstream_domain):
error = gettext(
"The project space {} is already a downstream project space of {}."
).format(downstream_domain, upstream_domain)
raise DomainLinkAlreadyExists(error)
if not user_has_admin_access_in_all_domains(couch_user, [upstream_domain, downstream_domain]):
error = gettext("You must be an admin in both project spaces to create a link.")
raise DomainLinkNotAllowed(error)
return DomainLink.link_domains(downstream_domain, upstream_domain)
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 test_multiple_master_links(self):
link1 = DomainLink.link_domains('linked1', 'master')
link2 = DomainLink.link_domains('linked2', 'master')
self.assertNotEqual(link1.pk, link2.pk)
def test_double_link(self):
DomainLink.link_domains('linked', 'master')
with self.assertRaises(DomainLinkError):
DomainLink.link_domains('linked', 'master2')
def test_linking_existing(self):
link = DomainLink.link_domains('linked', 'master')
link1 = DomainLink.link_domains('linked', 'master')
self.assertEqual(link.pk, link1.pk)
def handle(self, downstream_url, upstream_domain, **options):
DomainLink.link_domains(downstream_url, upstream_domain)
