def test_create_org_special_characters(self):
# period in mnemonic
org = OrganizationFactory(name='test', mnemonic='org.1')
self.assertTrue(org.id)
self.assertEqual(org.mnemonic, 'org.1')
# hyphen in mnemonic
org = OrganizationFactory(name='test', mnemonic='org-1')
self.assertTrue(org.id)
self.assertEqual(org.mnemonic, 'org-1')
# underscore in mnemonic
org = OrganizationFactory(name='test', mnemonic='org_1')
self.assertTrue(org.id)
self.assertEqual(org.mnemonic, 'org_1')
# all characters in mnemonic
org = OrganizationFactory(name='test', mnemonic='org.1_2-3')
self.assertTrue(org.id)
self.assertEqual(org.mnemonic, 'org.1_2-3')
# @ characters in mnemonic
org = OrganizationFactory(name='test', mnemonic='org@1')
self.assertTrue(org.id)
self.assertEqual(org.mnemonic, 'org@1')
class OrganizationLogoViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.organization = OrganizationFactory(mnemonic='org-1')
self.user = UserProfileFactory(organizations=[self.organization])
self.token = self.user.get_token()
@patch('core.common.services.S3.upload_base64')
def test_post_200(self, upload_base64_mock):
upload_base64_mock.return_value = 'orgs/org-1/logo.png'
self.assertIsNone(self.organization.logo_url)
self.assertIsNone(self.organization.logo_path)
response = self.client.post(
self.organization.uri + 'logo/',
dict(base64='base64-data'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
expected_logo_url = 'http://oclapi2-dev.s3.amazonaws.com/orgs/org-1/logo.png'
self.assertEqual(response.data['logo_url'].replace('https://', 'http://'), expected_logo_url)
self.organization.refresh_from_db()
self.assertEqual(self.organization.logo_url.replace('https://', 'http://'), expected_logo_url)
self.assertEqual(self.organization.logo_path, 'orgs/org-1/logo.png')
upload_base64_mock.assert_called_once_with('base64-data', 'orgs/org-1/logo.png', False, True)
def setUp(self):
super().setUp()
self.superuser = UserProfile.objects.get(is_superuser=True)
self.user = UserProfileFactory(username='******')
self.org_private = OrganizationFactory(mnemonic='private-org', public_access=ACCESS_TYPE_NONE)
self.org_public_view = OrganizationFactory(mnemonic='public-view-org', public_access=ACCESS_TYPE_VIEW)
self.org_public_edit = OrganizationFactory(mnemonic='public-edit-org', public_access=ACCESS_TYPE_EDIT)
self.user_org_public = OrganizationFactory(mnemonic='user-public-view-org', public_access=ACCESS_TYPE_VIEW)
self.user_org_private = OrganizationFactory(mnemonic='user-private-org', public_access=ACCESS_TYPE_NONE)
self.user.organizations.set([self.user_org_private, self.user_org_public])
self.token = self.user.get_token()
def test_collection_and_version_import(self):
OrganizationFactory(mnemonic='PEPFAR')
self.assertFalse(
Collection.objects.filter(
mnemonic='MER-R-MOH-Facility-FY19').exists())
data = '{"type": "Collection", "id": "MER-R-MOH-Facility-FY19", "name": "MER R: MOH Facility Based FY19", ' \
'"default_locale": "en", "short_code": "MER-R-MOH-Facility-FY19", "external_id": "OBhi1PUW3OL", ' \
'"extras": {"Period": "FY19", "Period Description": "COP18 (FY19Q1)", "datim_sync_moh_fy19": true, ' \
'"DHIS2-Dataset-Code": "MER_R_MOH"}, "collection_type": "Code List", "full_name": ' \
'"MER Results: MOH Facility Based FY19", "owner": "PEPFAR", "public_access": "View", ' \
'"owner_type": "Organization", "supported_locales": "en"}\n' \
'{"type": "Collection Version", "id": "FY19.v0", ' \
'"description": "Initial release of FY19 DATIM-MOH definitions", ' \
'"collection": "MER-R-MOH-Facility-FY19", "released": true, "owner": "PEPFAR", ' \
'"owner_type": "Organization"}'
importer = BulkImportInline(data, 'ocladmin', True)
importer.run()
self.assertTrue(
Collection.objects.filter(mnemonic='MER-R-MOH-Facility-FY19',
version='HEAD').exists())
self.assertTrue(
Collection.objects.filter(mnemonic='MER-R-MOH-Facility-FY19',
version='FY19.v0').exists())
self.assertEqual(importer.processed, 2)
self.assertEqual(len(importer.created), 1)
self.assertEqual(len(importer.updated), 1)
self.assertEqual(importer.failed, [])
self.assertTrue(importer.elapsed_seconds > 0)
def test_source_import_success(self):
OrganizationFactory(mnemonic='DemoOrg')
self.assertFalse(Source.objects.filter(mnemonic='DemoSource').exists())
data = {
"type": "Source",
"id": "DemoSource",
"short_code": "DemoSource",
"name": "OCL Demo Source",
"full_name": "OCL Demo Source",
"owner_type": "Organization",
"owner": "DemoOrg",
"description": "Source used for demo purposes",
"default_locale": "en",
"source_type": "Dictionary",
"public_access": "View",
"supported_locales": "en",
"custom_validation_schema": "None"
}
importer = BulkImportInline(json.dumps(data), 'ocladmin', True)
importer.run()
self.assertTrue(
Source.objects.filter(mnemonic='DemoSource',
version='HEAD').exists())
self.assertEqual(importer.processed, 1)
self.assertEqual(len(importer.created), 1)
self.assertEqual(importer.created[0], data)
self.assertTrue(importer.elapsed_seconds > 0)
def setUp(self):
self.user = UserProfileFactory()
self.org = OrganizationFactory()
self.token = self.user.get_token()
self.source = OrganizationSourceFactory()
self.user_pin = self.user.pins.create(resource=self.source)
self.org_pin = self.org.pins.create(resource=self.source)
def test_get_200_with_subscribed_orgs(self):
response = self.client.get(
'/users/{}/?includeSubscribedOrgs=false'.format(
self.user.username),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['username'], self.user.username)
self.assertEqual(response.data['name'], self.user.name)
self.assertEqual(response.data['url'], self.user.uri)
self.assertFalse('subscribed_orgs' in response.data)
response = self.client.get(
'/users/{}/?includeSubscribedOrgs=true'.format(self.user.username),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['username'], self.user.username)
self.assertEqual(len(response.data['subscribed_orgs']), 0)
org = OrganizationFactory()
self.user.organizations.add(org)
response = self.client.get(
'/users/{}/?includeSubscribedOrgs=true'.format(self.user.username),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['username'], self.user.username)
self.assertEqual(len(response.data['subscribed_orgs']), 1)
def test_post_201(self):
source = OrganizationSourceFactory()
user = UserProfileFactory()
org = OrganizationFactory()
token = user.get_token()
response = self.client.post(user.uri + 'pins/',
dict(resource_type='Source',
resource_id=source.id),
HTTP_AUTHORIZATION='Token ' + token,
format='json')
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['resource_uri'], source.uri)
self.assertEqual(response.data['user_id'], user.id)
self.assertIsNone(response.data['organization_id'])
self.assertIsNotNone(response.data['resource'])
self.assertIsNotNone(response.data['uri'])
response = self.client.post(org.uri + 'pins/',
dict(resource_type='Source',
resource_id=source.id),
HTTP_AUTHORIZATION='Token ' + token,
format='json')
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['resource_uri'], source.uri)
self.assertEqual(response.data['organization_id'], org.id)
self.assertIsNone(response.data['user_id'])
self.assertIsNotNone(response.data['resource'])
self.assertIsNotNone(response.data['uri'])
def test_source_and_version_import(self):
OrganizationFactory(mnemonic='DemoOrg')
self.assertFalse(Source.objects.filter(mnemonic='DemoSource').exists())
data = '{"type": "Source", "id": "DemoSource", "short_code": "DemoSource", "name": "OCL Demo Source", ' \
'"full_name": "OCL Demo Source", "owner_type": "Organization", "owner": "DemoOrg", "description": ' \
'"Source used for demo purposes", "default_locale": "en", "source_type": "Dictionary", ' \
'"public_access": "View", "supported_locales": "en", "custom_validation_schema": "None"}\n' \
'{"type": "Source Version", "id": "initial", "source": "DemoSource", "description": "Initial empty ' \
'repository version", "released": true, "owner": "DemoOrg", "owner_type": "Organization"} '
importer = BulkImportInline(data, 'ocladmin', True)
importer.run()
self.assertTrue(
Source.objects.filter(mnemonic='DemoSource',
version='HEAD').exists())
self.assertTrue(
Source.objects.filter(mnemonic='DemoSource',
version='initial').exists())
self.assertEqual(importer.processed, 2)
self.assertEqual(len(importer.created), 1)
self.assertEqual(len(importer.updated), 1)
self.assertEqual(importer.failed, [])
self.assertTrue(importer.elapsed_seconds > 0)
def test_uri(self):
org = OrganizationFactory(mnemonic='org-1')
user = UserProfileFactory(username='******')
self.assertEqual(Pin().uri, None)
self.assertEqual(
Pin(id=1, organization=org).uri, '/orgs/org-1/pins/1/')
self.assertEqual(Pin(id=2, user=user).uri, '/users/user-1/pins/2/')
def test_parent(self):
org = OrganizationFactory()
user = UserProfileFactory()
self.assertEqual(Pin().parent, None)
self.assertEqual(Pin(organization=org).parent, org)
self.assertEqual(Pin(user=user).parent, user)
self.assertEqual(Pin(user=user, organization=org).parent, org)
def test_get_403(self):
private_org = OrganizationFactory(public_access=ACCESS_TYPE_NONE)
response = self.client.get('/orgs/{}/members/'.format(
private_org.mnemonic),
format='json')
self.assertEqual(response.status_code, 403)
def test_put_404(self):
new_org = OrganizationFactory()
response = self.client.put(
'/orgs/{}/members/foobar/'.format(new_org.mnemonic),
HTTP_AUTHORIZATION='Token ' + self.superuser.get_token(),
format='json')
self.assertEqual(response.status_code, 404)
def test_to_source_shorthand(self):
to_concept = ConceptFactory(
parent=OrganizationSourceFactory(mnemonic='foobar',
organization=OrganizationFactory(
mnemonic='org-foo')))
mapping = Mapping(to_concept=to_concept)
self.assertEqual(mapping.to_source_shorthand, 'org-foo:foobar')
def test_from_source_owner_mnemonic(self):
from_concept = ConceptFactory(
parent=OrganizationSourceFactory(mnemonic='foobar',
organization=OrganizationFactory(
mnemonic='org-foo')))
mapping = Mapping(from_concept=from_concept)
self.assertEqual(mapping.from_source_owner_mnemonic, 'org-foo')
def test_org_import(self):
self.assertFalse(
Organization.objects.filter(mnemonic='DATIM-MOH-BI-FY19').exists())
OrganizationFactory(mnemonic='DATIM-MOH-BI-FY19', location='blah')
self.assertTrue(
Organization.objects.filter(mnemonic='DATIM-MOH-BI-FY19').exists())
data = '{"type": "Organization", "__action": "DELETE", "id": "DATIM-MOH-BI-FY19"}\n' \
'{"name": "DATIM MOH Burundi", "extras": {"datim_moh_country_code": "BI", "datim_moh_period": "FY19",' \
' "datim_moh_object": true}, "location": "Burundi", "public_access": "None", "type": "Organization",' \
' "id": "DATIM-MOH-BI-FY19"}'
importer = BulkImportInline(data, 'ocladmin', True)
importer.run()
self.assertTrue(
Organization.objects.filter(mnemonic='DATIM-MOH-BI-FY19').exists())
self.assertEqual(importer.processed, 2)
self.assertEqual(len(importer.created), 1)
self.assertEqual(len(importer.deleted), 1)
self.assertTrue(importer.elapsed_seconds > 0)
data = {
"name": "DATIM MOH Burundi",
"extras": {
"datim_moh_country_code": "BI",
"datim_moh_period": "FY19",
"datim_moh_object": True
},
"location": "Burundi",
"public_access": "None",
"type": "Organization",
"id": "DATIM-MOH-BI-FY19"
}
importer = BulkImportInline(json.dumps(data), 'ocladmin', True)
importer.run()
self.assertEqual(importer.processed, 1)
self.assertEqual(len(importer.created), 0)
self.assertEqual(len(importer.failed), 0)
self.assertEqual(len(importer.deleted), 0)
self.assertEqual(len(importer.exists), 1)
self.assertEqual(importer.exists[0], data)
self.assertTrue(importer.elapsed_seconds > 0)
data = {"type": "Organization", "__action": "DELETE", "id": "FOOBAR"}
importer = BulkImportInline(json.dumps(data), 'ocladmin', True)
importer.run()
self.assertEqual(importer.processed, 1)
self.assertEqual(len(importer.created), 0)
self.assertEqual(len(importer.failed), 0)
self.assertEqual(len(importer.deleted), 0)
self.assertEqual(len(importer.exists), 0)
self.assertEqual(len(importer.not_found), 1)
self.assertEqual(importer.not_found[0], data)
self.assertTrue(importer.elapsed_seconds > 0)
def test_delete_organization_task(self):
org = OrganizationFactory()
delete_organization(0)
self.assertTrue(Organization.objects.filter(id=org.id).exists())
delete_organization(org.id)
self.assertFalse(Organization.objects.filter(id=org.id).exists())
def test_from_concept_shorthand(self):
from_concept = ConceptFactory(
mnemonic='concept-foo',
parent=OrganizationSourceFactory(
mnemonic='source-foo',
organization=OrganizationFactory(mnemonic='org-foo')))
mapping = Mapping(from_concept=from_concept)
self.assertEqual(mapping.from_concept_shorthand,
'org-foo:source-foo:concept-foo')
def setUp(self):
super().setUp()
self.org = OrganizationFactory()
self.user = self.org.created_by
self.token = self.user.get_token()
self.dummy_config = dict(tabs=[dict(default=True)])
self.config = ClientConfig(config=self.dummy_config,
name='foobar',
resource=self.org)
self.config.save()
def test_get_200(self):
org = OrganizationFactory(extras=dict())
user = UserProfileFactory(organizations=[org])
token = user.get_token()
response = self.client.get(org.uri + 'extras/',
HTTP_AUTHORIZATION='Token ' + token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict())
org = OrganizationFactory(extras=dict(foo='bar'))
response = self.client.get(org.uri + 'extras/',
HTTP_AUTHORIZATION='Token ' + token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='bar'))
def test_put_403(self):
self.assertEqual(self.user.organizations.count(), 1)
new_org = OrganizationFactory()
response = self.client.put('/orgs/{}/members/{}/'.format(
new_org.mnemonic, self.user.username),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 403)
self.assertEqual(self.user.organizations.count(), 1)
def test_post_403(self):
OrganizationFactory(mnemonic='org')
response = self.client.post('/orgs/org/collections/',
dict(
default_locale='en',
supported_locales='en,fr',
id='coll',
),
format='json')
self.assertEqual(response.status_code, 403)
def test_post_without_to_and_from_concept_url_201(self):
source = UserSourceFactory(user=self.user, mnemonic='source')
response = self.client.post(
source.mappings_url,
{
"map_type": "Same As",
"from_source_url": source.uri,
"from_source_version": "2.46",
"from_concept_code": "32700-7",
"from_concept_name": "Microscopic observation [Identifier] in Blood by Malaria smear",
"to_source_url": "/orgs/WHO/sources/ICPC-2/",
"to_source_version": "v11",
"to_concept_code": "A73",
"to_concept_name": "Malaria"
},
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['from_source_url'], source.uri)
self.assertEqual(response.data['from_source_version'], '2.46')
self.assertEqual(response.data['from_concept_code'], '32700-7')
self.assertEqual(
response.data['from_concept_name'], 'Microscopic observation [Identifier] in Blood by Malaria smear'
)
self.assertEqual(response.data['to_source_url'], "/orgs/WHO/sources/ICPC-2/")
self.assertEqual(response.data['to_source_version'], 'v11')
self.assertEqual(response.data['to_concept_code'], 'A73')
self.assertEqual(response.data['to_concept_name'], 'Malaria')
mapping = source.mappings.first()
self.assertIsNone(mapping.from_concept_id)
self.assertIsNone(mapping.to_concept_id)
self.assertIsNone(mapping.to_source_id)
org = OrganizationFactory(mnemonic='WHO')
source = OrganizationSourceFactory(organization=org, mnemonic='ICPC-2')
source.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.to_source_url, source.uri)
self.assertEqual(mapping.to_source, source)
self.assertIsNone(mapping.to_concept)
concept = ConceptFactory(parent=source, mnemonic='A73', names=[LocalizedTextFactory(name='Malaria Updated')])
concept.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.to_concept_code, 'A73')
self.assertEqual(mapping.to_concept_name, 'Malaria')
self.assertEqual(mapping.to_source, source)
self.assertEqual(mapping.to_source, concept.parent)
self.assertEqual(mapping.to_concept, concept)
def test_clean(self):
org = OrganizationFactory()
pin = Pin(resource=org)
with self.assertRaises(ValidationError) as ex:
pin.full_clean()
self.assertEqual(
ex.exception.message_dict,
dict(
parent=['Pin needs to be owned by a user or an organization.'
]))
pin.organization = org
pin.full_clean()
def test_organization_delete(self):
org = OrganizationFactory()
org_id = org.id
self.assertTrue(org.is_active)
self.assertTrue(Organization.objects.filter(id=org_id).exists())
org.soft_delete()
self.assertFalse(org.is_active)
self.assertTrue(Organization.objects.filter(id=org_id).exists())
org.delete()
self.assertFalse(Organization.objects.filter(id=org_id).exists())
def test_post_400(self):
org = OrganizationFactory(mnemonic='org')
user = UserProfileFactory(organizations=[org])
response = self.client.post(
'/orgs/org/collections/',
dict(
default_locale='en', supported_locales='en,fr', id='coll',
extras=dict(foo='bar')
),
HTTP_AUTHORIZATION='Token ' + user.get_token(),
format='json'
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, dict(name=[ErrorDetail(string='This field is required.', code='required')]))
self.assertEqual(org.collection_set.count(), 0)
def test_post_201(self):
org = OrganizationFactory(mnemonic='org')
user = UserProfileFactory(organizations=[org], username='******')
response = self.client.post('/orgs/org/collections/',
dict(default_locale='en',
supported_locales='en,fr',
id='coll',
name='Collection',
mnemonic='coll',
extras=dict(foo='bar')),
HTTP_AUTHORIZATION='Token ' +
user.get_token(),
format='json')
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(response.data['uuid'])
self.assertEqual(response.data['id'], 'coll')
self.assertEqual(response.data['name'], 'Collection')
self.assertEqual(response.data['default_locale'], 'en')
self.assertEqual(response['Location'], '/orgs/org/collections/coll/')
self.assertEqual(org.collection_set.count(), 1)
response = self.client.post('/users/user/collections/',
dict(default_locale='en',
supported_locales='en,fr',
id='coll',
name='Collection',
mnemonic='coll',
extras=dict(foo='bar')),
HTTP_AUTHORIZATION='Token ' +
user.get_token(),
format='json')
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(response.data['uuid'])
self.assertEqual(response.data['id'], 'coll')
self.assertEqual(response.data['name'], 'Collection')
self.assertEqual(response.data['default_locale'], 'en')
self.assertEqual(response['Location'], '/users/user/collections/coll/')
self.assertEqual(user.collection_set.count(), 1)
org_collection = org.collection_set.first()
user_collection = user.collection_set.first()
self.assertNotEqual(org_collection.id, user_collection.id)
def test_update_order(self):
org = OrganizationFactory(mnemonic='org-1')
org_pin1 = Pin(organization=org,
resource=OrganizationSourceFactory(organization=org))
org_pin1.save()
self.assertEqual(org_pin1.order, 0)
org_pin2 = Pin(
organization=org,
resource=OrganizationCollectionFactory(organization=org))
org_pin2.save()
self.assertEqual(org_pin2.order, 1)
org_pin3 = Pin(
organization=org,
resource=OrganizationCollectionFactory(organization=org))
org_pin3.save()
self.assertEqual(org_pin3.order, 2)
org_pin3.to(0)
org_pin1.refresh_from_db()
org_pin2.refresh_from_db()
org_pin3.refresh_from_db()
self.assertEqual(org_pin3.order, 0)
self.assertEqual(org_pin1.order, 1)
self.assertEqual(org_pin2.order, 2)
org_pin3.to(2)
org_pin1.refresh_from_db()
org_pin2.refresh_from_db()
org_pin3.refresh_from_db()
self.assertEqual(org_pin1.order, 0)
self.assertEqual(org_pin2.order, 1)
self.assertEqual(org_pin3.order, 2)
org_pin3.to(1)
org_pin1.refresh_from_db()
org_pin2.refresh_from_db()
org_pin3.refresh_from_db()
self.assertEqual(org_pin1.order, 0)
self.assertEqual(org_pin3.order, 1)
self.assertEqual(org_pin2.order, 2)
def test_org_active_inactive_should_affect_children(self):
org = OrganizationFactory(is_active=True)
source = OrganizationSourceFactory(organization=org, is_active=True)
collection = OrganizationCollectionFactory(organization=org, is_active=True)
org.is_active = False
org.save()
source.refresh_from_db()
collection.refresh_from_db()
self.assertFalse(org.is_active)
self.assertFalse(source.is_active)
self.assertFalse(collection.is_active)
org.is_active = True
org.save()
source.refresh_from_db()
collection.refresh_from_db()
self.assertTrue(org.is_active)
self.assertTrue(source.is_active)
self.assertTrue(collection.is_active)
def test_siblings(self):
org = OrganizationFactory()
config1 = ClientConfig(
name='first',
resource=org,
config=dict(tabs=[dict(foo='bar', default=True)]))
config1.save()
self.assertEqual(config1.siblings.count(), 0)
config2 = ClientConfig(
name='second',
resource=org,
config=dict(tabs=[dict(foo='bar', default=True)]))
config2.save()
self.assertEqual(config1.siblings.count(), 1)
self.assertEqual(config1.siblings.first().id, config2.id)
self.assertEqual(config2.siblings.count(), 1)
self.assertEqual(config2.siblings.first().id, config1.id)
