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())
