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)