def test_get_200_with_mappings(self): concept1 = ConceptFactory(parent=self.source, mnemonic='conceptA') concept2 = ConceptFactory(parent=self.source, mnemonic='conceptB') mapping = MappingFactory(parent=self.source, from_concept=concept2.get_latest_version(), to_concept=concept1.get_latest_version()) response = self.client.get("/concepts/", HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 2) self.assertEqual([response.data[0]['id'], response.data[1]['id']], [concept2.mnemonic, concept1.mnemonic]) self.assertEqual(response['num_found'], '2') self.assertEqual(response['num_returned'], '2') self.assertFalse(response.has_header('previous')) self.assertFalse(response.has_header('next')) response = self.client.get( "/concepts/?limit=1&verbose=true&includeMappings=true", HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['id'], concept2.mnemonic) self.assertEqual(len(response.data[0]['mappings']), 1) self.assertEqual(response.data[0]['mappings'][0]['uuid'], str(mapping.id)) self.assertEqual(response['num_found'], '2') self.assertEqual(response['num_returned'], '1') self.assertTrue( '/concepts/?limit=1&verbose=true&includeMappings=true&page=2' in response['next']) self.assertFalse(response.has_header('previous')) response = self.client.get( "/concepts/?page=2&limit=1&verbose=true&includeInverseMappings=true", HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['id'], concept1.mnemonic) self.assertEqual(response['num_found'], '2') self.assertEqual(response['num_returned'], '1') self.assertEqual(len(response.data[0]['mappings']), 1) self.assertEqual(response.data[0]['mappings'][0]['uuid'], str(mapping.id)) self.assertTrue( '/concepts/?page=1&limit=1&verbose=true&includeInverseMappings=true' in response['previous']) self.assertFalse(response.has_header('next'))
def test_export_collection(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) collection = OrganizationCollectionFactory() collection.add_references([concept1.uri, concept2.uri, mapping.uri]) collection.refresh_from_db() export_collection(collection.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, { **CollectionDetailSerializer(collection).data, 'concepts': ANY, 'mappings': ANY }) exported_concepts = exported_data['concepts'] expected_concepts = ConceptVersionDetailSerializer( [concept2.get_latest_version(), concept1.get_latest_version()], 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.get_latest_version()], many=True).data self.assertEqual(len(exported_mappings), 1) self.assertEqual(expected_mappings, exported_mappings) s3_upload_key = collection.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_extra_delete_204(self): names = [LocalizedTextFactory()] concept = ConceptFactory(parent=self.source, names=names, extras=dict(foo='bar', tao='ching')) self.assertEqual(concept.versions.count(), 1) def extra_url(extra): return "/orgs/{}/sources/{}/concepts/{}/extras/{}/".format( self.organization.mnemonic, self.source.mnemonic, concept.mnemonic, extra) response = self.client.delete(extra_url('tao'), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) concept.refresh_from_db() self.assertFalse('tao' in concept.extras) self.assertEqual(concept.versions.count(), 2) latest_version = concept.get_latest_version() self.assertEqual(latest_version.extras, dict(foo='bar')) self.assertEqual(latest_version.comment, 'Deleted extra tao.')
def test_seed_children_task(self): collection = OrganizationCollectionFactory() concept = ConceptFactory() mapping = MappingFactory() concept_latest_version = concept.get_latest_version() mapping_latest_version = mapping.get_latest_version() collection.add_references([ concept_latest_version.version_url, mapping_latest_version.version_url ]) self.assertEqual(collection.references.count(), 2) self.assertEqual(collection.concepts.count(), 1) self.assertEqual(collection.mappings.count(), 1) collection_v1 = OrganizationCollectionFactory( organization=collection.organization, version='v1', mnemonic=collection.mnemonic) self.assertEqual(collection_v1.references.count(), 0) self.assertEqual(collection_v1.concepts.count(), 0) self.assertEqual(collection_v1.mappings.count(), 0) seed_children('collection', collection_v1.id) # pylint: disable=no-value-for-parameter self.assertEqual(collection_v1.references.count(), 2) self.assertEqual(collection_v1.concepts.count(), 1) self.assertEqual(collection_v1.mappings.count(), 1) self.assertEqual( list(collection_v1.references.values_list('expression', flat=True)), list(collection.references.values_list('expression', flat=True)), )
def test_add_references(self): collection = OrganizationCollectionFactory() self.assertEqual(collection.concepts.count(), 0) self.assertEqual(collection.references.count(), 0) self.assertEqual(collection.active_concepts, 0) source = OrganizationSourceFactory() concept = ConceptFactory(parent=source, sources=[source]) concept_expression = concept.uri collection.add_references([concept_expression]) collection.refresh_from_db() self.assertEqual(collection.concepts.count(), 1) self.assertEqual(collection.references.count(), 1) self.assertEqual(collection.references.first().expression, concept_expression) self.assertEqual(collection.concepts.first(), concept.get_latest_version()) self.assertEqual(collection.active_concepts, 1) result = collection.add_references([concept_expression]) self.assertEqual( result, { concept_expression: [ 'Concept or Mapping reference name must be unique in a collection.' ] }) collection.refresh_from_db() self.assertEqual(collection.concepts.count(), 1) self.assertEqual(collection.references.count(), 1) self.assertEqual(collection.active_concepts, 1)
def test_add_references_openmrs_schema(self): collection = OrganizationCollectionFactory( custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS) self.assertEqual(collection.concepts.count(), 0) self.assertEqual(collection.references.count(), 0) source = OrganizationSourceFactory() concept = ConceptFactory(parent=source, sources=[source]) concept_expression = concept.uri collection.add_references([concept_expression]) self.assertEqual(collection.concepts.count(), 1) self.assertEqual(collection.references.count(), 1) self.assertEqual(collection.references.first().expression, concept_expression) self.assertEqual(collection.concepts.first(), concept.get_latest_version()) concept2 = ConceptFactory(parent=source, sources=[source]) collection.add_references([concept2.uri]) self.assertEqual(collection.concepts.count(), 2) self.assertEqual(collection.references.count(), 2)
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_get_concepts(self): reference = CollectionReference() reference.expression = '/unknown/uri/' unknown_expression_concepts = reference.get_concepts() self.assertTrue(isinstance(unknown_expression_concepts, QuerySet)) self.assertFalse(unknown_expression_concepts.exists()) concept = ConceptFactory() reference.expression = concept.uri concepts = reference.get_concepts() self.assertTrue(isinstance(concepts, QuerySet)) self.assertEqual(concepts.count(), 1) self.assertEqual(concepts.first(), concept.get_latest_version()) ConceptFactory(parent=concept.parent, version='v1', mnemonic=concept.mnemonic, versioned_object=concept) reference.expression = drop_version(concept.uri) + 'versions/' concepts = reference.get_concepts().order_by('created_at') self.assertTrue(isinstance(concepts, QuerySet)) self.assertEqual(concepts.count(), 2) self.assertListEqual(list(concepts.all()), list(concept.versions.all()))
def test_delete_204_specific_expression(self): response = self.client.delete( '/collections/coll/references/', dict(expressions=[self.concept.get_latest_version().uri]), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.assertEqual(self.collection.references.count(), 0) self.assertEqual(self.collection.concepts.count(), 0) concept = ConceptFactory() latest_version = concept.get_latest_version() MappingFactory(from_concept=latest_version, parent=concept.parent) response = self.client.put( '/collections/coll/references/?cascade=sourcemappings', dict(data=dict(mappings=[latest_version.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 2) self.assertEqual(self.collection.concepts.count(), 1) self.assertEqual(self.collection.mappings.count(), 1) response = self.client.delete( '/collections/coll/references/?cascade=sourcemappings', dict(expressions=[latest_version.uri]), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 0) self.assertEqual(self.collection.concepts.count(), 0) self.assertEqual(self.collection.mappings.count(), 0)
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_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) for attr in ['active_concepts', 'active_mappings', 'versions', 'summary']: self.assertFalse(attr in response.data[0]) 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.get_latest_version().uri ), format='json' ) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) response = self.client.get( '/orgs/{}/collections/?verbose=true&includeSummary=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) self.assertEqual(response.data[0]['summary'], dict(versions=1, active_concepts=1, active_mappings=0))
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.get_latest_version().id)
def test_source_version_delete(self): source = OrganizationSourceFactory(version=HEAD) concept = ConceptFactory(mnemonic='concept1', version=HEAD, sources=[source], parent=source) self.assertTrue(source.is_latest_version) self.assertEqual(concept.get_latest_version().sources.count(), 1) 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.assertEqual(concept.get_latest_version().sources.count(), 2) self.assertTrue(version1.is_latest_version) self.assertFalse(source.is_latest_version) source_versions = Source.objects.filter( mnemonic=source.mnemonic, version='v1', ) self.assertTrue(source_versions.exists()) self.assertEqual(version1.concepts.count(), 1) version1.delete() source.refresh_from_db() self.assertFalse( Source.objects.filter( version='v1', mnemonic=source.mnemonic, ).exists()) self.assertTrue(source.is_latest_version) self.assertEqual(concept.get_latest_version().sources.count(), 1)
def test_get_concepts(self): collection = OrganizationCollectionFactory() source = OrganizationSourceFactory() concept = ConceptFactory(parent=source, sources=[source]) concept_expression = concept.uri collection.add_references([concept_expression]) concepts = collection.get_concepts() self.assertEqual(concepts.count(), 1) self.assertEqual(concepts.first(), concept.get_latest_version()) self.assertEqual(collection.get_concepts(start=0, end=10).count(), 1) self.assertEqual(collection.get_concepts(start=1, end=2).count(), 0)
def test_post_with_source_versions_201(self): source1 = UserSourceFactory(user=self.user, mnemonic='source1') source1_v1 = UserSourceFactory( user=source1.parent, mnemonic=source1.mnemonic, version='v1.1' ) concept1 = ConceptFactory(parent=source1, sources=[source1_v1]) source2 = UserSourceFactory(user=self.user, mnemonic='source2') source2_v1 = UserSourceFactory( user=source2.parent, mnemonic=source1.mnemonic, version='v2.1' ) concept2 = ConceptFactory(parent=source2, sources=[source2_v1]) response = self.client.post( source1.mappings_url, { "map_type": "Same As", "from_concept_url": concept1.get_latest_version().uri, "from_source_version": "v1.1", "to_concept_url": concept2.get_latest_version().uri, "to_source_version": "v2.1" }, HTTP_AUTHORIZATION='Token ' + self.token, ) self.assertEqual(response.status_code, 201) self.assertEqual(response.data['from_source_url'], source1.uri) self.assertEqual(response.data['from_source_version'], 'v1.1') self.assertEqual(response.data['from_concept_code'], concept1.mnemonic) self.assertEqual(response.data['from_concept_name'], None) self.assertEqual(response.data['to_source_url'], source2.uri) self.assertEqual(response.data['to_source_version'], 'v2.1') self.assertEqual(response.data['to_concept_code'], concept2.mnemonic) self.assertEqual(response.data['to_concept_name'], None) mapping = source1.mappings.first() self.assertEqual(mapping.from_concept, concept1.get_latest_version()) self.assertEqual(mapping.to_concept, concept2.get_latest_version()) self.assertEqual(mapping.to_source, source2) self.assertEqual(mapping.from_source, source1)
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_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_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_get_duplicate_concept_name_from_multiple_sources_200(self): 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 + 'concept/', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 409) response = self.client.get(self.collection.concepts_url + 'concept/?uri=' + concept2.uri, HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data['uuid'], str(concept2.get_latest_version().id))
def test_post_to_concept_does_not_exists_201(self): source = UserSourceFactory(user=self.user) concept = ConceptFactory(parent=source) response = self.client.post( source.mappings_url, { "map_type": "Same As", "from_concept_url": concept.get_latest_version().uri, "to_concept_url": "/orgs/WHO/sources/ICPC-2/concepts/A73/" }, 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'], None) self.assertEqual(response.data['from_concept_code'], concept.mnemonic) self.assertEqual(response.data['from_concept_name'], None) self.assertEqual(response.data['to_source_url'], '/orgs/WHO/sources/ICPC-2/') self.assertEqual(response.data['to_source_version'], None) self.assertEqual(response.data['to_concept_code'], 'A73') self.assertEqual(response.data['to_concept_name'], None)
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.uri, mapping.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.uri)
def test_get_latest_versions_for_queryset(self): # pylint: disable=too-many-locals self.assertEqual( Concept.get_latest_versions_for_queryset( Concept.objects.none()).count(), 0) source1 = OrganizationSourceFactory() concept1 = ConceptFactory(parent=source1, mnemonic='common-name-1') concept1_latest = concept1.get_latest_version() ConceptFactory(version='v1', parent=source1, is_latest_version=False, mnemonic=concept1.mnemonic) concept2 = ConceptFactory(parent=source1) concept2_latest = concept2.get_latest_version() ConceptFactory(version='v1', parent=source1, is_latest_version=False, mnemonic=concept2.mnemonic) concept3 = ConceptFactory(parent=source1, mnemonic='common-name-2') concept3_latest = concept3.get_latest_version() ConceptFactory(version='v1', parent=source1, is_latest_version=False, mnemonic=concept3.mnemonic) source2 = OrganizationSourceFactory() concept4 = ConceptFactory(parent=source2, mnemonic='common-name-1') concept4_latest = concept4.get_latest_version() ConceptFactory(version='v1', parent=source2, is_latest_version=False, mnemonic=concept4.mnemonic) concept5 = ConceptFactory(parent=source2) concept5_latest = concept5.get_latest_version() ConceptFactory(version='v1', parent=source2, is_latest_version=False, mnemonic=concept5.mnemonic) concept6 = ConceptFactory(parent=source2, mnemonic='common-name-2') concept6_latest = concept6.get_latest_version() ConceptFactory(version='v1', parent=source2, is_latest_version=False, mnemonic=concept6.mnemonic) latest_versions = Concept.get_latest_versions_for_queryset( Concept.objects.filter(parent=source1)) self.assertEqual(latest_versions.count(), 3) self.assertEqual(list(latest_versions.order_by('created_at')), [concept1_latest, concept2_latest, concept3_latest]) latest_versions = Concept.get_latest_versions_for_queryset( Concept.objects.filter(parent=source2)) self.assertEqual(latest_versions.count(), 3) self.assertEqual(list(latest_versions.order_by('created_at')), [concept4_latest, concept5_latest, concept6_latest]) latest_versions = Concept.get_latest_versions_for_queryset( Concept.objects.filter(mnemonic='common-name-1')) self.assertEqual(latest_versions.count(), 2) self.assertEqual(list(latest_versions.order_by('created_at')), [concept1_latest, concept4_latest]) latest_versions = Concept.get_latest_versions_for_queryset( Concept.objects.filter(mnemonic='common-name-2', version='v1')) self.assertEqual(latest_versions.count(), 2) self.assertEqual(list(latest_versions.order_by('created_at')), [concept3_latest, concept6_latest])
def test_get_mappings(self): # pylint: disable=too-many-locals source1 = OrganizationSourceFactory() source2 = OrganizationSourceFactory() concept1 = ConceptFactory(parent=source1) concept2 = ConceptFactory(parent=source1) concept3 = ConceptFactory(parent=source2) concept4 = ConceptFactory(parent=source2) concept1_latest = concept1.get_latest_version() concept2_latest = concept2.get_latest_version() concept3_latest = concept3.get_latest_version() concept4_latest = concept4.get_latest_version() mapping1 = MappingFactory(from_concept=concept1_latest, to_concept=concept2_latest, parent=source1) mapping2 = MappingFactory(from_concept=concept1_latest, to_concept=concept3_latest, parent=source1) mapping3 = MappingFactory(from_concept=concept1_latest, to_concept=concept3_latest, parent=source2) mapping4 = MappingFactory(from_concept=concept4_latest, to_concept=concept1_latest, parent=source1) mapping5 = MappingFactory(from_concept=concept4_latest, to_concept=concept1_latest, parent=source2) MappingFactory(from_concept=concept1_latest, to_concept=concept2_latest, parent=source2) mappings = concept1.get_unidirectional_mappings() self.assertEqual(mappings.count(), 2) self.assertEqual(list(mappings.order_by('created_at')), [mapping1, mapping2]) mappings = concept1.get_indirect_mappings() self.assertEqual(mappings.count(), 1) self.assertEqual(list(mappings.order_by('created_at')), [mapping4]) mappings = concept1.get_bidirectional_mappings() self.assertEqual(mappings.count(), 3) self.assertEqual(list(mappings.order_by('created_at')), [mapping1, mapping2, mapping4]) mappings = concept1_latest.get_unidirectional_mappings() self.assertEqual(mappings.count(), 2) self.assertEqual(list(mappings.order_by('created_at')), [mapping1, mapping2]) mappings = concept1_latest.get_indirect_mappings() self.assertEqual(mappings.count(), 1) self.assertEqual(list(mappings.order_by('created_at')), [mapping4]) mappings = concept1_latest.get_bidirectional_mappings() self.assertEqual(mappings.count(), 3) self.assertEqual(list(mappings.order_by('created_at')), [mapping1, mapping2, mapping4]) mappings = concept2.get_unidirectional_mappings() self.assertEqual(mappings.count(), 0) mappings = concept2.get_indirect_mappings() self.assertEqual(mappings.count(), 1) self.assertEqual(list(mappings.order_by('created_at')), [mapping1]) mappings = concept3.get_unidirectional_mappings() self.assertEqual(mappings.count(), 0) mappings = concept3.get_indirect_mappings() self.assertEqual(mappings.count(), 1) self.assertEqual(list(mappings.order_by('created_at')), [mapping3]) mappings = concept4.get_unidirectional_mappings() self.assertEqual(mappings.count(), 1) self.assertEqual(list(mappings.order_by('created_at')), [mapping5]) mappings = concept4.get_indirect_mappings() self.assertEqual(mappings.count(), 0)
class ConceptVersionsViewTest(OCLAPITestCase): def setUp(self): super().setUp() self.concept = ConceptFactory(names=[LocalizedTextFactory()]) self.user = UserProfileFactory( organizations=[self.concept.parent.organization]) self.token = self.user.get_token() def test_get_200(self): self.assertEqual(self.concept.versions.count(), 1) response = self.client.get(self.concept.versions_url) self.assertEqual(response.status_code, 200) versions = response.data self.assertEqual(len(versions), 1) version = versions[0] latest_version = self.concept.get_latest_version() self.assertEqual(version['uuid'], str(latest_version.id)) self.assertEqual(version['id'], self.concept.mnemonic) self.assertEqual(version['url'], self.concept.uri) self.assertEqual(version['version_url'], latest_version.uri) self.assertTrue(version['is_latest_version']) self.assertIsNone(version['previous_version_url']) response = self.client.put(self.concept.uri, { 'names': [{ 'locale': 'ab', 'locale_preferred': True, 'name': 'c1 name', 'name_type': 'Fully Specified' }], 'datatype': 'foobar', 'update_comment': 'Updated datatype' }, HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(self.concept.versions.count(), 2) response = self.client.get(self.concept.versions_url) self.assertEqual(response.status_code, 200) versions = response.data self.assertEqual(len(versions), 2) prev_latest_version = [ v for v in versions if v['uuid'] == version['uuid'] ][0] new_latest_version = [ v for v in versions if v['uuid'] != version['uuid'] ][0] latest_version = self.concept.get_latest_version() self.assertEqual(new_latest_version['version_url'], latest_version.uri) self.assertEqual(str(latest_version.id), str(new_latest_version['uuid'])) self.assertEqual(prev_latest_version['uuid'], version['uuid']) self.assertEqual(new_latest_version['previous_version_url'], prev_latest_version['version_url']) self.assertEqual(new_latest_version['previous_version_url'], version['version_url']) self.assertIsNone(prev_latest_version['previous_version_url']) self.assertFalse(prev_latest_version['is_latest_version']) self.assertTrue(new_latest_version['is_latest_version']) self.assertEqual(new_latest_version['datatype'], 'foobar') self.assertEqual(prev_latest_version['datatype'], 'None')
def test_hierarchy(self): # pylint: disable=too-many-statements # Av1 parent_concept = ConceptFactory( names=[LocalizedTextFactory(locale='en', name='English', locale_preferred=True)]) self.assertEqual(parent_concept.versions.count(), 1) source = parent_concept.parent # Av1 -> None and Av2 -> Bv1 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(parent_concept.versions.count(), 2) self.assertEqual(child_concept.versions.count(), 1) self.assertEqual(list(child_concept.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), []) # Av1 -> None and Av2 -> Bv1, Bv2 and Bv2 -> Cv1 child_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': [child_concept.uri] }) self.assertEqual(child_child_concept.errors, {}) self.assertIsNotNone(child_child_concept.id) self.assertEqual(parent_concept.versions.count(), 2) self.assertEqual(child_concept.versions.count(), 2) self.assertEqual(child_child_concept.versions.count(), 1) self.assertEqual(list(child_child_concept.parent_concept_urls), [child_concept.uri]) self.assertEqual(list(child_child_concept.get_latest_version().parent_concept_urls), [child_concept.uri]) self.assertEqual(list(child_child_concept.child_concept_urls), []) self.assertEqual(list(child_concept.child_concept_urls), [child_child_concept.uri]) self.assertEqual(list(child_concept.parent_concept_urls), [parent_concept.uri]) self.assertEqual(list(child_concept.get_latest_version().child_concept_urls), [child_child_concept.uri]) self.assertEqual(list(child_concept.get_latest_version().parent_concept_urls), [parent_concept.uri]) self.assertEqual(list(parent_concept.child_concept_urls), [child_concept.uri]) # Av1 -> None and Av2 -> Bv1,Bv2 -> Cv1 and Av3 -> Bv3,Cv2 Concept.create_new_version_for( instance=child_child_concept.clone(), data=dict( parent_concept_urls=[parent_concept.uri], names=[dict(locale='en', name='English', locale_preferred=True)] ), user=child_child_concept.created_by ) self.assertEqual(parent_concept.versions.count(), 3) self.assertEqual(child_concept.versions.count(), 3) self.assertEqual(child_child_concept.versions.count(), 2) child_child_latest_version = child_child_concept.get_latest_version() self.assertEqual(list(child_child_concept.parent_concept_urls), [parent_concept.uri]) self.assertEqual(list(child_child_latest_version.parent_concept_urls), [parent_concept.uri]) self.assertEqual(list(child_child_latest_version.prev_version.parent_concept_urls), [child_concept.url]) parent_concept_latest_version = parent_concept.get_latest_version() self.assertListEqual( sorted(list(parent_concept.child_concept_urls)), sorted([child_concept.uri, child_child_concept.uri]) ) self.assertEqual( sorted(list(parent_concept_latest_version.child_concept_urls)), sorted([child_concept.uri, child_child_concept.uri]) ) self.assertEqual(list(parent_concept_latest_version.prev_version.child_concept_urls), [child_concept.url]) child_latest_version = child_concept.get_latest_version() self.assertEqual(list(child_concept.child_concept_urls), []) self.assertEqual(list(child_latest_version.child_concept_urls), []) self.assertEqual(list(child_latest_version.prev_version.child_concept_urls), [child_child_concept.uri]) # Av1 -> None and Av2 -> Bv1,Bv2 -> Cv1 and Av3 -> Bv3,Cv2 and Av4 -> Bv4 -> Cv3 Concept.create_new_version_for( instance=child_child_concept.clone(), data=dict( parent_concept_urls=[child_concept.uri], names=[dict(locale='en', name='English', locale_preferred=True)] ), user=child_child_concept.created_by ) self.assertEqual(parent_concept.versions.count(), 4) self.assertEqual(child_concept.versions.count(), 4) self.assertEqual(child_child_concept.versions.count(), 3) child_child_latest_version = child_child_concept.get_latest_version() self.assertEqual( list(child_child_concept.parent_concept_urls), [child_concept.uri]) self.assertEqual( list(child_child_latest_version.parent_concept_urls), [child_concept.uri]) self.assertEqual( list(child_child_latest_version.prev_version.parent_concept_urls), [parent_concept.url]) self.assertEqual( list(child_child_latest_version.prev_version.prev_version.parent_concept_urls), [child_concept.url]) child_latest_version = child_concept.get_latest_version() self.assertEqual(list(child_concept.child_concept_urls), [child_child_concept.uri]) self.assertEqual(list(child_latest_version.child_concept_urls), [child_child_concept.uri]) self.assertEqual( list(child_latest_version.prev_version.child_concept_urls), [] ) self.assertEqual( list(child_latest_version.prev_version.prev_version.child_concept_urls), [child_child_concept.uri] ) self.assertEqual( list(child_latest_version.prev_version.prev_version.prev_version.child_concept_urls), [] ) parent_concept_latest_version = parent_concept.get_latest_version() self.assertListEqual( sorted(list(parent_concept.child_concept_urls)), sorted([child_concept.uri]) ) self.assertEqual( sorted(list(parent_concept_latest_version.child_concept_urls)), sorted([child_concept.uri]) ) self.assertEqual( sorted(list(parent_concept_latest_version.prev_version.child_concept_urls)), sorted([child_concept.uri, child_child_concept.uri]) ) self.assertEqual( list(parent_concept_latest_version.prev_version.prev_version.child_concept_urls), [child_concept.uri] ) self.assertEqual( list(parent_concept_latest_version.prev_version.prev_version.prev_version.child_concept_urls), [] ) # Av1 -> None and Av2 -> Bv1,Bv2 -> Cv1 and Av3 -> Bv3,Cv2 and Av4 -> Bv4 -> Cv3 and Av4 -> Bv5 -> None and Cv4 Concept.create_new_version_for( instance=child_child_concept.clone(), data=dict( parent_concept_urls=[], names=[dict(locale='en', name='English', locale_preferred=True)] ), user=child_child_concept.created_by ) self.assertEqual(parent_concept.versions.count(), 4) self.assertEqual(child_concept.versions.count(), 5) self.assertEqual(child_child_concept.versions.count(), 4) child_child_latest_version = child_child_concept.get_latest_version() self.assertEqual( list(child_child_concept.parent_concept_urls), []) self.assertEqual( list(child_child_latest_version.parent_concept_urls), []) self.assertEqual( list(child_child_latest_version.prev_version.parent_concept_urls), [child_concept.uri]) self.assertEqual( list(child_child_latest_version.prev_version.prev_version.parent_concept_urls), [parent_concept.url]) self.assertEqual( list(child_child_latest_version.prev_version.prev_version.prev_version.parent_concept_urls), [child_concept.url] ) child_latest_version = child_concept.get_latest_version() self.assertEqual(list(child_concept.child_concept_urls), []) self.assertEqual(list(child_latest_version.child_concept_urls), []) self.assertEqual(list(child_latest_version.prev_version.child_concept_urls), [child_child_concept.uri]) self.assertEqual( list(child_latest_version.prev_version.prev_version.child_concept_urls), [] ) self.assertEqual( list(child_latest_version.prev_version.prev_version.prev_version.child_concept_urls), [child_child_concept.uri] ) self.assertEqual( list(child_latest_version.prev_version.prev_version.prev_version.prev_version.child_concept_urls), [] ) parent_concept_latest_version = parent_concept.get_latest_version() self.assertListEqual( sorted(list(parent_concept.child_concept_urls)), sorted([child_concept.uri]) ) self.assertEqual( sorted(list(parent_concept_latest_version.child_concept_urls)), sorted([child_concept.uri]) ) self.assertEqual( sorted(list(parent_concept_latest_version.prev_version.child_concept_urls)), sorted([child_concept.uri, child_child_concept.uri]) ) self.assertEqual( list(parent_concept_latest_version.prev_version.prev_version.child_concept_urls), [child_concept.uri] ) self.assertEqual( list(parent_concept_latest_version.prev_version.prev_version.prev_version.child_concept_urls), [] )
class ConceptExtraRetrieveUpdateDestroyViewTest(OCLAPITestCase): def setUp(self): super().setUp() self.extras = dict(foo='bar', tao='ching') self.concept = ConceptFactory(extras=self.extras, names=[LocalizedTextFactory()]) self.user = UserProfileFactory( organizations=[self.concept.parent.organization]) self.token = self.user.get_token() def test_get_200(self): response = self.client.get(self.concept.uri + 'extras/foo/', format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, dict(foo='bar')) def test_get_404(self): response = self.client.get(self.concept.uri + 'extras/bar/', format='json') self.assertEqual(response.status_code, 404) def test_put_200(self): self.assertEqual(self.concept.versions.count(), 1) self.assertEqual(self.concept.get_latest_version().extras, self.extras) self.assertEqual(self.concept.extras, self.extras) response = self.client.put(self.concept.uri + 'extras/foo/', dict(foo='foobar'), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, dict(foo='foobar')) self.assertEqual(self.concept.versions.count(), 2) self.assertEqual(self.concept.get_latest_version().extras, dict(foo='foobar', tao='ching')) self.concept.refresh_from_db() self.assertEqual(self.concept.extras, dict(foo='foobar', tao='ching')) def test_put_400(self): self.assertEqual(self.concept.versions.count(), 1) self.assertEqual(self.concept.get_latest_version().extras, self.extras) self.assertEqual(self.concept.extras, self.extras) response = self.client.put(self.concept.uri + 'extras/foo/', dict(tao='foobar'), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 400) self.assertEqual(response.data, ['Must specify foo param in body.']) self.assertEqual(self.concept.versions.count(), 1) self.assertEqual(self.concept.get_latest_version().extras, self.extras) self.concept.refresh_from_db() self.assertEqual(self.concept.extras, self.extras) def test_delete_204(self): self.assertEqual(self.concept.versions.count(), 1) self.assertEqual(self.concept.get_latest_version().extras, self.extras) self.assertEqual(self.concept.extras, self.extras) response = self.client.delete(self.concept.uri + 'extras/foo/', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.assertEqual(self.concept.versions.count(), 2) self.assertEqual(self.concept.get_latest_version().extras, dict(tao='ching')) self.assertEqual(self.concept.versions.first().extras, dict(foo='bar', tao='ching')) self.concept.refresh_from_db() self.assertEqual(self.concept.extras, dict(tao='ching'))
def test_post_with_source_versions_without_to_concept_exists_201(self): source = UserSourceFactory(user=self.user, mnemonic='source') source_v1 = UserSourceFactory( user=source.parent, mnemonic=source.mnemonic, version='v1.1' ) concept = ConceptFactory(parent=source, sources=[source_v1]) response = self.client.post( source.mappings_url, { "map_type": "Same As", "from_concept_url": concept.get_latest_version().uri, "from_source_version": "v1.1", "to_source_url": "/orgs/WHO/sources/ICPC-2/", "to_source_version": "v11", "to_concept_code": "A73", }, 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'], 'v1.1') self.assertEqual(response.data['from_concept_code'], concept.mnemonic) self.assertEqual(response.data['from_concept_name'], None) 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'], None) mapping = source.mappings.first() self.assertEqual(mapping.from_concept, concept.get_latest_version()) self.assertIsNone(mapping.to_concept_id) self.assertIsNone(mapping.to_source_id) concept2 = ConceptFactory(parent=source, sources=[source_v1], names=[LocalizedTextFactory()]) self.assertIsNotNone(concept2.display_name) response = self.client.post( source.mappings_url, { "map_type": "Same As", "from_concept_url": concept2.get_latest_version().uri, "from_source_version": "v1.1", "to_source_url": "/orgs/WHO/sources/ICPC-2/v11/", "to_concept_code": "A73", }, 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'], 'v1.1') self.assertEqual(response.data['from_concept_code'], concept2.mnemonic) self.assertEqual(response.data['from_concept_name'], None) 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'], None) mapping = source.mappings.last() self.assertEqual(mapping.from_concept, concept2.get_latest_version()) self.assertIsNone(mapping.to_concept_id) self.assertIsNone(mapping.to_source_id) response = self.client.post( source.mappings_url, { "map_type": "Same As", "from_concept_url": concept2.get_latest_version().uri, "from_source_version": "v1.1", "to_source_url": "/orgs/WHO/sources/ICPC-2/v11/", "to_concept_code": "A73", }, 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.']} )
class CollectionReferencesViewTest(OCLAPITestCase): def setUp(self): super().setUp() self.user = UserProfileFactory() self.token = self.user.get_token() self.collection = UserCollectionFactory(mnemonic='coll', user=self.user) self.concept = ConceptFactory() self.reference = CollectionReference(expression=self.concept.uri) self.reference.full_clean() self.reference.save() self.collection.references.add(self.reference) self.collection.concepts.set(self.reference.concepts) self.assertEqual(self.collection.references.count(), 1) self.assertEqual(self.collection.concepts.count(), 1) def test_get_404(self): response = self.client.get('/collections/foobar/references/', format='json') self.assertEqual(response.status_code, 404) def test_get_200(self): response = self.client.get('/collections/coll/references/', format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['expression'], self.concept.get_latest_version().uri) self.assertEqual(response.data[0]['reference_type'], 'concepts') response = self.client.get( '/collections/coll/references/?q={}&search_sort=desc'.format( self.concept.get_latest_version().uri), format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['expression'], self.concept.get_latest_version().uri) self.assertEqual(response.data[0]['reference_type'], 'concepts') response = self.client.get( '/collections/coll/references/?q=/concepts/&search_sort=desc', format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) response = self.client.get( '/collections/coll/references/?q=/mappings/&search_sort=desc', format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 0) def test_delete_400(self): response = self.client.delete('/collections/coll/references/', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 400) def test_delete_204_random(self): response = self.client.delete('/collections/coll/references/', dict(expressions=['/foo/']), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.assertEqual(self.collection.references.count(), 1) self.assertEqual(self.collection.concepts.count(), 1) def test_delete_204_all_expressions(self): response = self.client.delete('/collections/coll/references/', dict(expressions='*'), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.assertEqual(self.collection.references.count(), 0) self.assertEqual(self.collection.concepts.count(), 0) def test_delete_204_specific_expression(self): response = self.client.delete( '/collections/coll/references/', dict(expressions=[self.concept.get_latest_version().uri]), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.assertEqual(self.collection.references.count(), 0) self.assertEqual(self.collection.concepts.count(), 0) concept = ConceptFactory() latest_version = concept.get_latest_version() MappingFactory(from_concept=latest_version, parent=concept.parent) response = self.client.put( '/collections/coll/references/?cascade=sourcemappings', dict(data=dict(mappings=[latest_version.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 2) self.assertEqual(self.collection.concepts.count(), 1) self.assertEqual(self.collection.mappings.count(), 1) response = self.client.delete( '/collections/coll/references/?cascade=sourcemappings', dict(expressions=[latest_version.uri]), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 204) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 0) self.assertEqual(self.collection.concepts.count(), 0) self.assertEqual(self.collection.mappings.count(), 0) @patch('core.collections.views.add_references') def test_put_202_all(self, add_references_mock): add_references_mock.delay = Mock() response = self.client.put('/collections/coll/references/', dict(data=dict(concepts='*')), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 202) self.assertEqual(response.data, []) add_references_mock.delay.assert_called_once_with( self.user, dict(concepts='*'), self.collection, 'http://testserver', False) def test_put_200_specific_expression(self): response = self.client.put( '/collections/coll/references/', dict(data=dict(concepts=[self.concept.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, [ dict( added=False, expression=self.concept.uri, message=[ 'Concept or Mapping reference name must be unique in a collection.' ]) ]) concept2 = ConceptFactory() response = self.client.put('/collections/coll/references/', dict(data=dict(concepts=[concept2.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 2) self.assertEqual(self.collection.concepts.count(), 2) self.assertEqual(self.collection.active_concepts, 2) self.assertEqual(self.collection.active_mappings, 0) self.assertTrue( self.collection.references.filter( expression=concept2.get_latest_version().uri).exists()) self.assertEqual(response.data, [ dict( added=True, expression=concept2.get_latest_version().uri, message= 'Added the latest versions of concept to the collection. Future updates will not be added' ' automatically.') ]) mapping = MappingFactory(from_concept=concept2, to_concept=self.concept, parent=self.concept.parent) response = self.client.put('/collections/coll/references/', dict(data=dict(mappings=[mapping.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 3) self.assertEqual(self.collection.concepts.count(), 2) self.assertEqual(self.collection.mappings.count(), 1) self.assertEqual(self.collection.active_concepts, 2) self.assertEqual(self.collection.active_mappings, 1) self.assertTrue( self.collection.references.filter( expression=mapping.get_latest_version().uri).exists()) self.assertEqual(response.data, [ dict( added=True, expression=mapping.get_latest_version().uri, message= 'Added the latest versions of mapping to the collection. Future updates will not be added' ' automatically.') ]) concept3 = ConceptFactory() latest_version = concept3.get_latest_version() mapping2 = MappingFactory(from_concept=latest_version, parent=concept3.parent) response = self.client.put( '/collections/coll/references/?cascade=sourcemappings', dict(data=dict(concepts=[latest_version.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 5) self.assertEqual(self.collection.concepts.count(), 3) self.assertEqual(self.collection.mappings.count(), 2) self.assertEqual(self.collection.active_concepts, 3) self.assertEqual(self.collection.active_mappings, 2) self.assertTrue( self.collection.references.filter( expression=mapping2.get_latest_version().uri).exists()) self.assertTrue( self.collection.references.filter( expression=latest_version.uri).exists())
def test_put_200_openmrs_schema(self): # pylint: disable=too-many-statements self.create_lookup_concept_classes() source = OrganizationSourceFactory( custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS) name = LocalizedTextFactory(locale='fr') concept = ConceptFactory(parent=source, names=[name]) self.assertEqual(concept.versions.count(), 1) response = self.client.put(concept.uri, { **self.concept_payload, 'datatype': 'None', 'update_comment': 'Updated datatype' }, HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertListEqual(list(response.data.keys()), [ 'uuid', 'id', 'external_id', 'concept_class', 'datatype', 'url', 'retired', 'source', 'owner', 'owner_type', 'owner_url', 'display_name', 'display_locale', 'names', 'descriptions', 'created_on', 'updated_on', 'versions_url', 'version', 'extras', 'name', 'type', 'update_comment', 'version_url', 'mappings', 'updated_by', 'created_by', 'internal_reference_id', 'parent_concept_urls', 'child_concept_urls' ]) names = response.data['names'] version = Concept.objects.last() concept.refresh_from_db() self.assertFalse(version.is_versioned_object) self.assertTrue(version.is_latest_version) self.assertEqual(version.versions.count(), 2) self.assertEqual(response.data['uuid'], str(version.id)) self.assertEqual(response.data['datatype'], 'None') self.assertEqual(response.data['update_comment'], 'Updated datatype') self.assertEqual(response.data['concept_class'], 'Procedure') self.assertEqual(response.data['url'], concept.uri) self.assertEqual(response.data['url'], version.versioned_object.uri) self.assertEqual(response.data['version_url'], version.uri) self.assertFalse(response.data['retired']) self.assertEqual(response.data['source'], source.mnemonic) self.assertEqual(response.data['owner'], source.organization.mnemonic) self.assertEqual(response.data['owner_type'], "Organization") self.assertEqual(response.data['owner_url'], source.organization.uri) self.assertEqual(response.data['display_name'], 'c1 name') self.assertEqual(response.data['display_locale'], 'en') self.assertEqual(response.data['versions_url'], concept.uri + 'versions/') self.assertEqual(response.data['version'], str(version.id)) self.assertEqual(response.data['extras'], dict(foo='bar')) self.assertEqual(response.data['type'], 'Concept') self.assertEqual(response.data['version_url'], version.uri) self.assertEqual(response.data['mappings'], []) self.assertTrue(concept.is_versioned_object) self.assertEqual(concept.datatype, "None") # same names in update names[0]['uuid'] = str(name.id) [name.pop('type', None) for name in names] # pylint: disable=expression-not-assigned response = self.client.put(concept.uri, { **self.concept_payload, 'names': names, 'datatype': 'Numeric', 'update_comment': 'Updated datatype' }, HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) concept.refresh_from_db() self.assertEqual(concept.datatype, "Numeric") self.assertEqual(concept.names.count(), 1) latest_version = concept.get_latest_version() prev_version = latest_version.prev_version self.assertEqual(latest_version.names.count(), 1) self.assertEqual(prev_version.names.count(), 1) self.assertEqual(prev_version.names.first().name, latest_version.names.first().name) self.assertEqual(prev_version.names.first().locale, latest_version.names.first().locale)
def test_put_200_specific_expression(self): response = self.client.put( '/collections/coll/references/', dict(data=dict(concepts=[self.concept.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, [ dict( added=False, expression=self.concept.uri, message=[ 'Concept or Mapping reference name must be unique in a collection.' ]) ]) concept2 = ConceptFactory() response = self.client.put('/collections/coll/references/', dict(data=dict(concepts=[concept2.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 2) self.assertEqual(self.collection.concepts.count(), 2) self.assertEqual(self.collection.active_concepts, 2) self.assertEqual(self.collection.active_mappings, 0) self.assertTrue( self.collection.references.filter( expression=concept2.get_latest_version().uri).exists()) self.assertEqual(response.data, [ dict( added=True, expression=concept2.get_latest_version().uri, message= 'Added the latest versions of concept to the collection. Future updates will not be added' ' automatically.') ]) mapping = MappingFactory(from_concept=concept2, to_concept=self.concept, parent=self.concept.parent) response = self.client.put('/collections/coll/references/', dict(data=dict(mappings=[mapping.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 3) self.assertEqual(self.collection.concepts.count(), 2) self.assertEqual(self.collection.mappings.count(), 1) self.assertEqual(self.collection.active_concepts, 2) self.assertEqual(self.collection.active_mappings, 1) self.assertTrue( self.collection.references.filter( expression=mapping.get_latest_version().uri).exists()) self.assertEqual(response.data, [ dict( added=True, expression=mapping.get_latest_version().uri, message= 'Added the latest versions of mapping to the collection. Future updates will not be added' ' automatically.') ]) concept3 = ConceptFactory() latest_version = concept3.get_latest_version() mapping2 = MappingFactory(from_concept=latest_version, parent=concept3.parent) response = self.client.put( '/collections/coll/references/?cascade=sourcemappings', dict(data=dict(concepts=[latest_version.uri])), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.collection.refresh_from_db() self.assertEqual(self.collection.references.count(), 5) self.assertEqual(self.collection.concepts.count(), 3) self.assertEqual(self.collection.mappings.count(), 2) self.assertEqual(self.collection.active_concepts, 3) self.assertEqual(self.collection.active_mappings, 2) self.assertTrue( self.collection.references.filter( expression=mapping2.get_latest_version().uri).exists()) self.assertTrue( self.collection.references.filter( expression=latest_version.uri).exists())