def test_seed_references(self):
collection1 = OrganizationCollectionFactory()
collection2 = OrganizationCollectionFactory(
version='v1',
mnemonic=collection1.mnemonic,
organization=collection1.organization)
self.assertTrue(collection1.is_head)
self.assertFalse(collection2.is_head)
source = OrganizationSourceFactory()
concept = ConceptFactory(parent=source, sources=[source])
concept_expression = concept.uri
collection1.add_references([concept_expression])
self.assertEqual(collection1.references.count(), 1)
self.assertEqual(collection2.references.count(), 0)
collection2.seed_references()
self.assertEqual(collection1.references.count(), 1)
self.assertEqual(collection2.references.count(), 1)
self.assertEqual(collection1.references.first().expression,
collection2.references.first().expression)
self.assertNotEqual(collection1.references.first().id,
collection2.references.first().id)
def test_names_get_200(self):
name = LocalizedTextFactory()
concept = ConceptFactory(parent=self.source, names=[name])
response = self.client.get(
"/orgs/{}/sources/{}/concepts/{}/names/".format(
self.organization.mnemonic, self.source.mnemonic, concept.mnemonic
),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(
dict(response.data[0]),
{
"uuid": str(name.id),
"external_id": None,
"type": 'ConceptName',
"locale": name.locale,
"locale_preferred": False,
"name": name.name,
"name_type": "FULLY_SPECIFIED"
}
)
def test_extra_get_200(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source,
names=names,
extras=dict(foo='bar', tao='ching'))
def extra_url(extra):
return "/orgs/{}/sources/{}/concepts/{}/extras/{}/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic, extra)
response = self.client.get(extra_url('tao'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(tao='ching'))
response = self.client.get(extra_url('foo'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='bar'))
response = self.client.get(extra_url('bar'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 404)
self.assertEqual(response.data, dict(detail='Not found.'))
def test_descriptions_for_default_locale(self):
es_locale = LocalizedTextFactory(locale='es', name='Not English')
en_locale = LocalizedTextFactory(locale='en', name='English')
concept = ConceptFactory(descriptions=(es_locale, en_locale))
self.assertEqual(concept.descriptions_for_default_locale,
[en_locale.name])
def test_get_200(self):
coll = OrganizationCollectionFactory(mnemonic='coll1')
response = self.client.get('/collections/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['short_code'], 'coll1')
self.assertEqual(response.data[0]['id'], 'coll1')
self.assertEqual(response.data[0]['url'], coll.uri)
response = self.client.get('/orgs/{}/collections/?verbose=true'.format(
coll.parent.mnemonic),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['short_code'], 'coll1')
self.assertEqual(response.data[0]['id'], 'coll1')
self.assertEqual(response.data[0]['url'], coll.uri)
concept = ConceptFactory()
reference = CollectionReference(expression=concept.uri)
reference.full_clean()
reference.save()
coll.references.add(reference)
coll.concepts.set(reference.concepts)
response = self.client.get(
'/orgs/{}/collections/?contains={}&includeReferences=true'.format(
coll.parent.mnemonic, concept.uri),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
class ConceptMappingsViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.concept = ConceptFactory(names=[LocalizedTextFactory()])
def test_get_200_for_concept(self):
mappings_url = self.concept.uri + 'mappings/'
response = self.client.get(mappings_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
direct_mapping = MappingFactory(parent=self.concept.parent,
from_concept=self.concept)
indirect_mapping = MappingFactory(parent=self.concept.parent,
to_concept=self.concept)
response = self.client.get(mappings_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['uuid'], str(direct_mapping.id))
response = self.client.get(mappings_url +
'?includeInverseMappings=true')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(
sorted([mapping['uuid'] for mapping in response.data]),
sorted([str(direct_mapping.id),
str(indirect_mapping.id)]))
def test_get_200_for_concept_version(self):
concept_latest_version = self.concept.get_latest_version()
mappings_url = concept_latest_version.uri + 'mappings/'
response = self.client.get(mappings_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
direct_mapping = MappingFactory(parent=self.concept.parent,
from_concept=concept_latest_version)
indirect_mapping = MappingFactory(parent=self.concept.parent,
to_concept=concept_latest_version)
response = self.client.get(mappings_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['uuid'], str(direct_mapping.id))
response = self.client.get(mappings_url +
'?includeInverseMappings=true')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(
sorted([mapping['uuid'] for mapping in response.data]),
sorted([str(direct_mapping.id),
str(indirect_mapping.id)]))
def test_names_post_201(self):
name = LocalizedTextFactory()
concept = ConceptFactory(parent=self.source, names=[name])
response = self.client.post(
"/orgs/{}/sources/{}/concepts/{}/names/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic), {
"type": 'ConceptName',
"locale": 'en',
"locale_preferred": False,
"name": 'foo',
"name_type": "Fully Specified"
},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 201)
self.assertEqual(
response.data, {
"uuid": ANY,
"external_id": None,
"type": 'ConceptName',
"locale": 'en',
"locale_preferred": False,
"name": 'foo',
"name_type": "Fully Specified"
})
self.assertEqual(concept.names.count(), 2)
def setUp(self):
super().setUp()
self.extras = dict(foo='bar', tao='ching')
self.concept = ConceptFactory(extras=self.extras)
self.user = UserProfileFactory(
organizations=[self.concept.parent.organization])
self.token = self.user.get_token()
def test_persist_new_version(self):
source = OrganizationSourceFactory(version=HEAD)
concept = ConceptFactory(mnemonic='concept1', parent=source)
self.assertEqual(source.concepts_set.count(), 2) # parent-child
self.assertEqual(source.concepts.count(), 2)
self.assertEqual(concept.sources.count(), 1)
self.assertTrue(source.is_latest_version)
version1 = OrganizationSourceFactory.build(
name='version1',
version='v1',
mnemonic=source.mnemonic,
organization=source.organization)
Source.persist_new_version(version1, source.created_by)
source.refresh_from_db()
self.assertFalse(source.is_latest_version)
self.assertEqual(source.concepts_set.count(), 2) # parent-child
self.assertEqual(source.concepts.count(), 2)
self.assertTrue(version1.is_latest_version)
self.assertEqual(version1.concepts.count(), 1)
self.assertEqual(
version1.concepts.first(),
source.concepts.filter(is_latest_version=True).first())
self.assertEqual(version1.concepts_set.count(), 0) # no direct child
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_display_name(self):
concept = ConceptFactory(names=())
self.assertIsNone(concept.display_name)
preferred_locale = LocalizedTextFactory(locale_preferred=True)
concept.names.add(preferred_locale)
self.assertEqual(concept.display_name, preferred_locale.name)
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_clone(self):
es_locale = LocalizedTextFactory(locale='es', name='Not English')
en_locale = LocalizedTextFactory(locale='en', name='English')
concept = ConceptFactory(descriptions=(es_locale, en_locale),
names=(en_locale, ),
released=True)
cloned_concept = concept.clone()
self.assertEqual(cloned_concept.version, '--TEMP--')
self.assertEqual(cloned_concept.mnemonic, concept.mnemonic)
self.assertEqual(cloned_concept.parent, concept.parent)
self.assertEqual(len(cloned_concept.cloned_names),
concept.names.count())
self.assertEqual(len(cloned_concept.cloned_descriptions),
concept.descriptions.count())
self.assertTrue(cloned_concept.released)
def test_all_names(self):
concept = ConceptFactory(names=[
LocalizedTextFactory(
name="name1", locale='en', locale_preferred=True),
LocalizedTextFactory(name='name2', locale='en', type='Short')
])
self.assertEqual(concept.all_names, ['name1', 'name2'])
def test_delete_references(self):
collection = OrganizationCollectionFactory()
source = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = MappingFactory(from_concept=concept1,
to_concept=concept2,
parent=source)
collection.add_references([concept1.uri, concept2.uri, mapping.uri])
self.assertEqual(collection.concepts.count(), 2)
self.assertEqual(collection.mappings.count(), 1)
self.assertEqual(collection.references.count(), 3)
collection.delete_references([
concept2.get_latest_version().uri,
mapping.get_latest_version().uri
])
self.assertEqual(collection.concepts.count(), 1)
self.assertEqual(collection.mappings.count(), 0)
self.assertEqual(collection.references.count(), 1)
self.assertEqual(collection.concepts.first().uri,
concept1.get_latest_version().uri)
self.assertEqual(collection.references.first().expression,
concept1.get_latest_version().uri)
def test_version_delete_400(self): # sources content referred in a private collection
concept = ConceptFactory(parent=self.source_v1)
collection = OrganizationCollectionFactory(public_access='None')
collection.add_references([concept.uri])
self.assertEqual(collection.concepts.count(), 1)
self.assertEqual(collection.concepts.first(), concept.get_latest_version())
response = self.client.delete(
self.source_v1.uri,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, {'detail': [CONTENT_REFERRED_PRIVATELY.format(self.source_v1.mnemonic)]})
self.assertEqual(self.source.versions.count(), 2)
self.assertTrue(self.source.versions.filter(version='v1').exists())
def test_default_description_locales(self):
es_locale = LocalizedTextFactory(locale='es')
en_locale = LocalizedTextFactory(locale='en')
concept = ConceptFactory(descriptions=(es_locale, en_locale))
default_description_locales = concept.default_description_locales
self.assertEqual(default_description_locales.count(), 1)
self.assertEqual(default_description_locales.first(), en_locale)
def test_hierarchy_one_parent_child(self):
parent_concept = ConceptFactory(
names=[LocalizedTextFactory(locale='en', name='English', locale_preferred=True)])
source = parent_concept.parent
child_concept = Concept.persist_new({
**factory.build(dict, FACTORY_CLASS=ConceptFactory), 'mnemonic': 'c1', 'parent': source,
'names': [LocalizedTextFactory.build(locale='en', name='English', locale_preferred=True)],
'parent_concept_urls': [parent_concept.uri]
})
parent_concept_latest_version = parent_concept.get_latest_version()
self.assertEqual(child_concept.errors, {})
self.assertIsNotNone(child_concept.id)
self.assertEqual(list(child_concept.parent_concept_urls), [parent_concept.uri])
self.assertEqual(list(child_concept.get_latest_version().parent_concept_urls), [parent_concept.uri])
self.assertEqual(list(child_concept.child_concept_urls), [])
self.assertEqual(list(parent_concept.child_concept_urls), [child_concept.uri])
self.assertEqual(list(parent_concept_latest_version.child_concept_urls), [child_concept.uri])
self.assertEqual(list(parent_concept_latest_version.prev_version.child_concept_urls), [])
another_child_concept = Concept.persist_new({
**factory.build(dict, FACTORY_CLASS=ConceptFactory), 'mnemonic': 'c2', 'parent': source,
'names': [LocalizedTextFactory.build(locale='en', name='English', locale_preferred=True)],
'parent_concept_urls': [parent_concept.uri]
})
parent_concept_latest_version = parent_concept.get_latest_version()
self.assertEqual(another_child_concept.errors, {})
self.assertIsNotNone(another_child_concept.id)
self.assertEqual(list(child_concept.parent_concept_urls), [parent_concept.uri])
self.assertEqual(list(child_concept.get_latest_version().parent_concept_urls), [parent_concept.uri])
self.assertEqual(list(child_concept.child_concept_urls), [])
self.assertEqual(list(another_child_concept.parent_concept_urls), [parent_concept.uri])
self.assertEqual(list(another_child_concept.get_latest_version().parent_concept_urls), [parent_concept.uri])
self.assertEqual(list(another_child_concept.child_concept_urls), [])
self.assertEqual(
sorted(list(parent_concept.child_concept_urls)),
sorted([child_concept.uri, another_child_concept.uri])
)
self.assertEqual(
sorted(list(parent_concept_latest_version.child_concept_urls)),
sorted([child_concept.uri, another_child_concept.uri])
)
self.assertEqual(list(parent_concept_latest_version.prev_version.child_concept_urls), [child_concept.uri])
def test_reference_as_concept_version(self):
concept = ConceptFactory()
expression = concept.uri
reference = CollectionReference(expression=expression)
reference.full_clean()
self.assertEqual(len(reference.concepts), 1)
self.assertTrue(isinstance(reference.concepts[0], Concept))
self.assertEqual(reference.concepts[0].id, concept.id)
def test_child_count_updates(self):
source = SourceFactory(version=HEAD)
self.assertEqual(source.active_concepts, 0)
concept = ConceptFactory(sources=[source], parent=source)
source.save()
self.assertEqual(source.active_concepts, 1)
self.assertEqual(source.last_concept_update, concept.updated_at)
self.assertEqual(source.last_child_update, source.last_concept_update)
def test_post_201(self):
source = UserSourceFactory(user=self.user)
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
response = self.client.post(
source.mappings_url,
dict(map_type='same as', from_concept_url=concept2.uri, to_concept_url=concept1.uri),
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['map_type'], 'same as')
self.assertEqual(response.data['from_concept_code'], concept2.mnemonic)
self.assertEqual(response.data['to_concept_code'], concept1.mnemonic)
mapping = source.mappings.first()
self.assertEqual(mapping.from_concept, concept2)
self.assertEqual(mapping.from_source, concept2.parent)
self.assertEqual(mapping.to_concept, concept1)
self.assertEqual(mapping.to_source, concept1.parent)
self.assertEqual(mapping.from_source_url, concept2.parent.uri)
self.assertEqual(mapping.to_source_url, concept1.parent.uri)
self.assertEqual(mapping.from_source_version, None)
self.assertEqual(mapping.to_source_version, None)
self.assertEqual(mapping.from_concept_name, None)
self.assertEqual(mapping.to_concept_name, None)
response = self.client.post(
source.mappings_url,
dict(map_type='same as', from_concept_url=concept2.uri, to_concept_url=concept1.uri),
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.data, {"__all__": ["Parent, map_type, from_concept, to_source, to_concept_code must be unique."]}
)
response = self.client.post(
source.mappings_url,
dict(map_type='same as', from_concept_url=concept2.uri, to_concept_url=concept2.uri),
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, {'__all__': ['Cannot map concept to itself.']})
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 test_export_source(self, s3_mock): # pylint: disable=too-many-locals
s3_mock.url_for = Mock(return_value='https://s3-url')
s3_mock.upload_file = Mock()
source = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = MappingFactory(from_concept=concept2, to_concept=concept1, parent=source)
source_v1 = OrganizationSourceFactory(mnemonic=source.mnemonic, organization=source.organization, version='v1')
concept1.sources.add(source_v1)
concept2.sources.add(source_v1)
mapping.sources.add(source_v1)
export_source(source_v1.id) # pylint: disable=no-value-for-parameter
latest_temp_dir = get_latest_dir_in_path('/tmp/')
zipped_file = zipfile.ZipFile(latest_temp_dir + '/export.zip')
exported_data = json.loads(zipped_file.read('export.json').decode('utf-8'))
self.assertEqual(exported_data, {**SourceDetailSerializer(source_v1).data, 'concepts': ANY, 'mappings': ANY})
exported_concepts = exported_data['concepts']
expected_concepts = ConceptVersionDetailSerializer([concept2, concept1], many=True).data
self.assertEqual(len(exported_concepts), 2)
self.assertIn(expected_concepts[0], exported_concepts)
self.assertIn(expected_concepts[1], exported_concepts)
exported_mappings = exported_data['mappings']
expected_mappings = MappingDetailSerializer([mapping], many=True).data
self.assertEqual(len(exported_mappings), 1)
self.assertEqual(expected_mappings, exported_mappings)
s3_upload_key = source_v1.export_path
s3_mock.upload_file.assert_called_once_with(
key=s3_upload_key, file_path=latest_temp_dir + '/export.zip', binary=True
)
s3_mock.url_for.assert_called_once_with(s3_upload_key)
import shutil
shutil.rmtree(latest_temp_dir)
def test_get_200(self):
response = self.client.get(self.collection.concepts_url,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
source1 = OrganizationSourceFactory()
source2 = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source1, mnemonic='concept')
concept2 = ConceptFactory(parent=source2, mnemonic='concept')
self.collection.add_references([concept1.uri, concept2.uri])
response = self.client.get(self.collection.concepts_url,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
def test_validate_reference_already_exists(self):
collection = OrganizationCollectionFactory()
ch_locale = LocalizedTextFactory(locale_preferred=True, locale='ch')
en_locale = LocalizedTextFactory(locale_preferred=True, locale='en')
concept = ConceptFactory(names=[ch_locale, en_locale])
reference = CollectionReference(expression=concept.uri)
reference.save()
collection.references.add(reference)
self.assertEqual(collection.references.count(), 1)
with self.assertRaises(ValidationError) as ex:
collection.validate(reference)
self.assertEqual(
ex.exception.message_dict, {
concept.get_latest_version().uri: [
'Concept or Mapping reference name must be unique in a collection.'
]
})
def test_persist_new(self):
source = SourceFactory(version=HEAD)
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = Mapping.persist_new({
**factory.build(dict, FACTORY_CLASS=MappingFactory), 'from_concept': concept1, 'to_concept': concept2,
'parent_id': source.id
}, source.created_by)
self.assertEqual(mapping.errors, {})
self.assertIsNotNone(mapping.id)
self.assertEqual(mapping.version, str(mapping.id))
self.assertEqual(source.mappings_set.count(), 1)
self.assertEqual(source.mappings.count(), 1)
self.assertEqual(
mapping.uri,
'/orgs/{}/sources/{}/mappings/{}/{}/'.format(
source.organization.mnemonic, source.mnemonic, mapping.mnemonic, mapping.id
)
)
def test_name_delete_204(self):
name1 = LocalizedTextFactory()
name2 = LocalizedTextFactory()
concept = ConceptFactory(parent=self.source, names=[name1, name2])
response = self.client.delete(
"/orgs/{}/sources/{}/concepts/{}/names/{}/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic, name2.id),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 204)
self.assertEqual(concept.versions.count(), 2)
self.assertEqual(concept.names.count(), 1)
self.assertEqual(concept.names.first().name, name1.name)
latest_version = concept.get_latest_version()
self.assertEqual(latest_version.names.count(), 1)
self.assertEqual(latest_version.names.first().name, name1.name)
self.assertEqual(latest_version.comment,
'Deleted {} in names.'.format(name2.name))
def test_extra_put_400(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source,
names=names,
extras=dict(foo='bar', tao='ching'))
def extra_url(extra):
return "/orgs/{}/sources/{}/concepts/{}/extras/{}/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic, extra)
response = self.client.put(extra_url('tao'),
dict(tao=None),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, ['Must specify tao param in body.'])
concept.refresh_from_db()
self.assertEqual(concept.extras, dict(foo='bar', tao='ching'))
def test_delete_204(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source, names=names)
concepts_url = "/orgs/{}/sources/{}/concepts/{}/".format(
self.organization.mnemonic, self.source.mnemonic, concept.mnemonic)
response = self.client.delete(concepts_url,
{'update_comment': 'Deleting it'},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 204)
concept.refresh_from_db()
self.assertEqual(concept.versions.count(), 2)
latest_version = concept.versions.order_by('-created_at').first()
self.assertTrue(latest_version.retired)
self.assertTrue(concept.retired)
self.assertTrue(latest_version.comment, 'Deleting it')
def test_last_child_update(self):
collection = OrganizationCollectionFactory()
self.assertEqual(collection.last_child_update, collection.updated_at)
mapping = MappingFactory()
collection.mappings.add(mapping)
self.assertEqual(collection.last_child_update, mapping.updated_at)
concept = ConceptFactory()
collection.concepts.add(concept)
self.assertEqual(collection.last_child_update, concept.updated_at)
