def test_extras_get_200(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source,
names=names,
extras=dict(foo='bar'))
extras_url = "/orgs/{}/sources/{}/concepts/{}/extras/".format(
self.organization.mnemonic, self.source.mnemonic, concept.mnemonic)
response = self.client.get(extras_url,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='bar'))
def test_delete_400(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source, names=names, retired=True)
concepts_url = "/orgs/{}/sources/{}/concepts/{}/".format(
self.organization.mnemonic, self.source.mnemonic, concept.mnemonic)
response = self.client.delete(concepts_url + '?includeRetired=true',
{'update_comment': 'Deleting it'},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data,
{'__all__': 'Concept is already retired'})
def test_post_without_to_and_from_concept_url_201(self):
source = UserSourceFactory(user=self.user, mnemonic='source')
response = self.client.post(
source.mappings_url,
{
"map_type": "Same As",
"from_source_url": source.uri,
"from_source_version": "2.46",
"from_concept_code": "32700-7",
"from_concept_name": "Microscopic observation [Identifier] in Blood by Malaria smear",
"to_source_url": "/orgs/WHO/sources/ICPC-2/",
"to_source_version": "v11",
"to_concept_code": "A73",
"to_concept_name": "Malaria"
},
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['from_source_url'], source.uri)
self.assertEqual(response.data['from_source_version'], '2.46')
self.assertEqual(response.data['from_concept_code'], '32700-7')
self.assertEqual(
response.data['from_concept_name'], 'Microscopic observation [Identifier] in Blood by Malaria smear'
)
self.assertEqual(response.data['to_source_url'], "/orgs/WHO/sources/ICPC-2/")
self.assertEqual(response.data['to_source_version'], 'v11')
self.assertEqual(response.data['to_concept_code'], 'A73')
self.assertEqual(response.data['to_concept_name'], 'Malaria')
mapping = source.mappings.first()
self.assertIsNone(mapping.from_concept_id)
self.assertIsNone(mapping.to_concept_id)
self.assertIsNone(mapping.to_source_id)
org = OrganizationFactory(mnemonic='WHO')
source = OrganizationSourceFactory(organization=org, mnemonic='ICPC-2')
source.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.to_source_url, source.uri)
self.assertEqual(mapping.to_source, source)
self.assertIsNone(mapping.to_concept)
concept = ConceptFactory(parent=source, mnemonic='A73', names=[LocalizedTextFactory(name='Malaria Updated')])
concept.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.to_concept_code, 'A73')
self.assertEqual(mapping.to_concept_name, 'Malaria')
self.assertEqual(mapping.to_source, source)
self.assertEqual(mapping.to_source, concept.parent)
self.assertEqual(mapping.to_concept, concept)
def test_concept_class_is_valid_attribute_negative(self):
source = OrganizationSourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept = Concept.persist_new(
dict(
mnemonic='concept1', version=HEAD, name='concept1', parent=source,
concept_class='XYZQWERT', datatype='None',
names=[LocalizedTextFactory.build(name='Grip', locale='es', locale_preferred=True)]
)
)
self.assertEqual(
concept.errors,
dict(concept_class=[OPENMRS_CONCEPT_CLASS])
)
def test_validate_openmrs_schema_duplicate_locale_type(self):
ch_locale = LocalizedTextFactory(locale_preferred=True, locale='ch')
en_locale = LocalizedTextFactory(locale_preferred=True, locale='en')
concept1 = ConceptFactory(names=[ch_locale, en_locale])
collection = OrganizationCollectionFactory(
custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
collection.concepts.add(concept1)
concept1_reference = CollectionReference(expression=concept1.uri)
concept1_reference.save()
collection.references.add(concept1_reference)
concept2 = ConceptFactory(names=[ch_locale, en_locale])
concept2_reference = CollectionReference(expression=concept2.uri)
with self.assertRaises(ValidationError) as ex:
collection.validate(concept2_reference)
self.assertEqual(
ex.exception.message_dict, {
'names': [
'Concept fully specified name must be unique for same collection and locale.'
]
})
def test_invalid_map_type(self):
source = OrganizationSourceFactory(
version=HEAD,
custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept1 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
concept2 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
mapping = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2,
map_type='Foo bar')
with self.assertRaises(ValidationError) as ex:
mapping.clean()
self.assertEqual(ex.exception.messages, ['Invalid mapping type'])
# 'Q-AND-A' is present in OpenMRS lookup values
mapping = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2,
map_type='Q-AND-A')
mapping.clean()
def test_unique_preferred_name_per_locale_within_concept_negative(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept1', version=HEAD, name='concept1', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(
name='Concept Non Unique Preferred Name', locale='es',
locale_preferred=True, type='FULLY_SPECIFIED'
),
LocalizedTextFactory.build(
name='Concept Non Unique Preferred Name', locale='es',
locale_preferred=True, type='FULLY_SPECIFIED'
),
]
)
)
self.assertEqual(
concept.errors,
{'names': ['A concept may not have more than one preferred name (per locale): '
'Concept Non Unique Preferred Name (locale: es, preferred: yes)']}
)
def test_get_to_concept_name(self):
mapping = Mapping()
self.assertIsNone(mapping.get_to_concept_name())
mapping = Mapping(to_concept_name='to-concept-name')
self.assertEqual(mapping.get_to_concept_name(), 'to-concept-name')
concept = ConceptFactory(names=[LocalizedTextFactory()])
self.assertIsNotNone(concept.display_name)
mapping = Mapping(to_concept=concept)
self.assertEqual(mapping.get_to_concept_name(), concept.display_name)
def test_names_post_400(self):
name = LocalizedTextFactory()
concept = ConceptFactory(parent=self.source, names=[name])
response = self.client.post(
"/orgs/{}/sources/{}/concepts/{}/names/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic), {
"type": 'ConceptName',
"name": name.name,
"name_type": "Fully Specified"
},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 400)
self.assertEqual(list(response.data.keys()), ['locale'])
def test_extra_delete_404(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source,
names=names,
extras=dict(foo='bar', tao='ching'))
def extra_url(extra):
return "/orgs/{}/sources/{}/concepts/{}/extras/{}/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic, extra)
response = self.client.delete(extra_url('bar'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 404)
def test_persist_new(self):
source = SourceFactory(version=HEAD)
concept = Concept.persist_new({
**factory.build(dict, FACTORY_CLASS=ConceptFactory), 'mnemonic': 'c1', 'parent': source,
'names': [LocalizedTextFactory.build(locale='en', name='English', locale_preferred=True)]
})
self.assertEqual(concept.errors, {})
self.assertIsNotNone(concept.id)
self.assertEqual(concept.version, str(concept.id))
self.assertEqual(source.concepts_set.count(), 1)
self.assertEqual(source.concepts.count(), 1)
self.assertEqual(
concept.uri,
'/orgs/{}/sources/{}/concepts/{}/{}/'.format(
source.organization.mnemonic, source.mnemonic, concept.mnemonic, concept.id
)
)
def test_extra_put_400(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source,
names=names,
extras=dict(foo='bar', tao='ching'))
def extra_url(extra):
return "/orgs/{}/sources/{}/concepts/{}/extras/{}/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic, extra)
response = self.client.put(extra_url('tao'),
dict(tao=None),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, ['Must specify tao param in body.'])
concept.refresh_from_db()
self.assertEqual(concept.extras, dict(foo='bar', tao='ching'))
def test_delete_204(self):
names = [LocalizedTextFactory()]
concept = ConceptFactory(parent=self.source, names=names)
concepts_url = "/orgs/{}/sources/{}/concepts/{}/".format(
self.organization.mnemonic, self.source.mnemonic, concept.mnemonic)
response = self.client.delete(concepts_url,
{'update_comment': 'Deleting it'},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 204)
concept.refresh_from_db()
self.assertEqual(concept.versions.count(), 2)
latest_version = concept.versions.order_by('-created_at').first()
self.assertTrue(latest_version.retired)
self.assertTrue(concept.retired)
self.assertTrue(latest_version.comment, 'Deleting it')
def test_concepts_should_have_unique_fully_specified_name_per_locale(self):
name_fully_specified1 = LocalizedTextFactory.build(name='FullySpecifiedName1')
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept1_data = {
**factory.build(dict, FACTORY_CLASS=ConceptFactory), 'mnemonic': 'c1', 'parent': source,
'names': [name_fully_specified1]
}
concept2_data = {
**factory.build(dict, FACTORY_CLASS=ConceptFactory), 'mnemonic': 'c2', 'parent': source,
'names': [name_fully_specified1]
}
concept1 = Concept.persist_new(concept1_data)
concept2 = Concept.persist_new(concept2_data)
self.assertEqual(concept1.errors, {})
self.assertEqual(
concept2.errors,
dict(names=[OPENMRS_FULLY_SPECIFIED_NAME_UNIQUE_PER_SOURCE_LOCALE +
': FullySpecifiedName1 (locale: en, preferred: no)'])
)
def test_unretire(self):
source = OrganizationSourceFactory(version=HEAD)
concept = Concept.persist_new({
**factory.build(dict, FACTORY_CLASS=ConceptFactory), 'mnemonic':
'c1',
'parent':
source,
'retired':
True,
'names': [
LocalizedTextFactory.build(locale='en',
name='English',
locale_preferred=True)
]
})
Concept.persist_clone(concept.clone(), concept.created_by)
concept_v1 = Concept.objects.order_by('-created_at').first()
concept.refresh_from_db()
self.assertEqual(concept.versions.count(), 2)
self.assertTrue(concept.retired)
self.assertFalse(concept.is_latest_version)
self.assertTrue(concept.is_versioned_object)
self.assertTrue(concept_v1.is_latest_version)
concept_v1.unretire(
concept.created_by,
'World needs you!') # concept will become old/prev version
concept.refresh_from_db()
concept_v1.refresh_from_db()
self.assertFalse(concept_v1.is_latest_version)
self.assertEqual(concept.versions.count(), 3)
self.assertFalse(concept.retired)
latest_version = concept.get_latest_version()
self.assertFalse(latest_version.retired)
self.assertEqual(latest_version.comment, 'World needs you!')
self.assertEqual(concept.unretire(concept.created_by),
{'__all__': CONCEPT_IS_ALREADY_NOT_RETIRED})
def test_names_get_200(self):
name = LocalizedTextFactory()
concept = ConceptFactory(parent=self.source, names=[name])
response = self.client.get(
"/orgs/{}/sources/{}/concepts/{}/names/".format(
self.organization.mnemonic, self.source.mnemonic,
concept.mnemonic),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(
dict(response.data[0]), {
"uuid": str(name.id),
"external_id": None,
"type": 'ConceptName',
"locale": name.locale,
"locale_preferred": False,
"name": name.name,
"name_type": "FULLY_SPECIFIED"
})
def test_post_using_canonical_url_201(self): # pylint: disable=too-many-statements
source = UserSourceFactory(user=self.user, mnemonic='source')
response = self.client.post(
source.mappings_url,
{
"map_type": "Same As",
"from_source_url": "http://loinc.org",
"from_source_version": "2.46",
"from_concept_code": "32700-7",
"from_concept_name": "Microscopic observation [Identifier] in Blood by Malaria smear",
"to_source_url": "http://who.int/ICPC-2",
"to_source_version": "v11",
"to_concept_code": "A73",
"to_concept_name": "Malaria"
},
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['from_source_url'], 'http://loinc.org')
self.assertEqual(response.data['from_source_version'], '2.46')
self.assertEqual(response.data['from_concept_code'], '32700-7')
self.assertEqual(
response.data['from_concept_name'], 'Microscopic observation [Identifier] in Blood by Malaria smear'
)
self.assertEqual(response.data['to_source_url'], "http://who.int/ICPC-2")
self.assertEqual(response.data['to_source_version'], 'v11')
self.assertEqual(response.data['to_concept_code'], 'A73')
self.assertEqual(response.data['to_concept_name'], 'Malaria')
mapping = source.mappings.first()
self.assertIsNone(mapping.from_concept_id)
self.assertIsNone(mapping.to_concept_id)
self.assertIsNone(mapping.to_source_id)
to_source = OrganizationSourceFactory(canonical_url="http://who.int/ICPC-2")
to_source.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.to_source_url, to_source.canonical_url)
self.assertEqual(mapping.to_source, to_source)
self.assertEqual(mapping.to_source_version, 'v11')
concept = ConceptFactory(parent=to_source, mnemonic='A73', names=[LocalizedTextFactory(name='foobar')])
concept.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.to_concept, concept)
self.assertTrue(mapping.to_concept_code == concept.mnemonic == 'A73')
self.assertEqual(mapping.to_concept_name, 'Malaria')
self.assertNotEqual(concept.display_name, 'Malaria')
self.assertEqual(mapping.from_concept, None)
self.assertEqual(mapping.from_source, None)
from_source = OrganizationSourceFactory(canonical_url="http://loinc.org")
from_source.update_mappings()
mapping.refresh_from_db()
self.assertTrue(mapping.from_source_url == from_source.canonical_url == "http://loinc.org")
self.assertEqual(mapping.from_source_version, "2.46")
self.assertEqual(mapping.from_source, from_source)
concept = ConceptFactory(parent=from_source, mnemonic='32700-7', names=[LocalizedTextFactory(name='foobar')])
concept.update_mappings()
mapping.refresh_from_db()
self.assertEqual(mapping.from_concept, concept)
self.assertTrue(mapping.from_concept_code == concept.mnemonic == '32700-7')
self.assertEqual(mapping.from_concept_name, 'Microscopic observation [Identifier] in Blood by Malaria smear')
self.assertNotEqual(concept.display_name, 'Microscopic observation [Identifier] in Blood by Malaria smear')
# retrievals with lookups
response = self.client.get(
mapping.uri,
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertTrue('from_concept' not in response.data)
self.assertTrue('to_concept' not in response.data)
self.assertTrue('from_source' not in response.data)
self.assertTrue('to_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupConcepts=false',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertTrue('from_concept' not in response.data)
self.assertTrue('to_concept' not in response.data)
self.assertTrue('from_source' not in response.data)
self.assertTrue('to_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupConcepts=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertIsNotNone(response.data['from_concept'])
self.assertIsNotNone(response.data['to_concept'])
self.assertTrue('from_source' not in response.data)
self.assertTrue('to_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupFromConcept=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertIsNotNone(response.data['from_concept'])
self.assertTrue('to_concept' not in response.data)
self.assertTrue('from_source' not in response.data)
self.assertTrue('to_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupToConcept=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertIsNotNone(response.data['to_concept'])
self.assertTrue('from_concept' not in response.data)
self.assertTrue('from_source' not in response.data)
self.assertTrue('to_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupSources=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertTrue('from_concept' not in response.data)
self.assertTrue('to_concept' not in response.data)
self.assertIsNotNone(response.data['from_source'])
self.assertIsNotNone(response.data['to_source'])
response = self.client.get(
mapping.uri + '?lookupFromSource=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertTrue('from_concept' not in response.data)
self.assertTrue('to_concept' not in response.data)
self.assertIsNotNone(response.data['from_source'])
self.assertTrue('to_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupToSource=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertTrue('from_concept' not in response.data)
self.assertTrue('to_concept' not in response.data)
self.assertIsNotNone(response.data['to_source'])
self.assertTrue('from_source' not in response.data)
response = self.client.get(
mapping.uri + '?lookupFromSource=true&lookupToSource=true',
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['url'], mapping.uri)
self.assertTrue('from_concept' not in response.data)
self.assertTrue('to_concept' not in response.data)
self.assertIsNotNone(response.data['from_source'])
self.assertIsNotNone(response.data['to_source'])
def test_display_locale(self):
preferred_locale = LocalizedTextFactory(locale_preferred=True)
concept = ConceptFactory(names=(preferred_locale, ))
self.assertEqual(concept.display_locale, preferred_locale.locale)
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),
[]
)
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 setUp(self):
super().setUp()
self.concept = ConceptFactory(names=[LocalizedTextFactory()])
self.user = UserProfileFactory(
organizations=[self.concept.parent.organization])
self.token = self.user.get_token()
def setUp(self):
super().setUp()
self.concept = ConceptFactory(names=[LocalizedTextFactory()])
def create_lookup_concept_classes(user=None, org=None):
from core.sources.tests.factories import OrganizationSourceFactory
from core.concepts.tests.factories import LocalizedTextFactory, ConceptFactory
org = org or Organization.objects.get(mnemonic='OCL')
user = user or UserProfile.objects.get(username='******')
classes_source = OrganizationSourceFactory(updated_by=user,
organization=org,
mnemonic="Classes",
version=HEAD)
datatypes_source = OrganizationSourceFactory(updated_by=user,
organization=org,
mnemonic="Datatypes",
version=HEAD)
nametypes_source = OrganizationSourceFactory(updated_by=user,
organization=org,
mnemonic="NameTypes",
version=HEAD)
descriptiontypes_source = OrganizationSourceFactory(
updated_by=user,
organization=org,
mnemonic="DescriptionTypes",
version=HEAD)
maptypes_source = OrganizationSourceFactory(updated_by=user,
organization=org,
mnemonic="MapTypes",
version=HEAD)
locales_source = OrganizationSourceFactory(updated_by=user,
organization=org,
mnemonic="Locales",
version=HEAD)
ConceptFactory(version=HEAD,
updated_by=user,
parent=classes_source,
concept_class="Concept Class",
names=[LocalizedTextFactory(name="Diagnosis")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=classes_source,
concept_class="Concept Class",
names=[LocalizedTextFactory(name="Drug")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=classes_source,
concept_class="Concept Class",
names=[LocalizedTextFactory(name="Test")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=classes_source,
concept_class="Concept Class",
names=[LocalizedTextFactory(name="Procedure")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=datatypes_source,
concept_class="Datatype",
names=[
LocalizedTextFactory(name="None"),
LocalizedTextFactory(name="N/A")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=datatypes_source,
concept_class="Datatype",
names=[LocalizedTextFactory(name="Numeric")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=datatypes_source,
concept_class="Datatype",
names=[LocalizedTextFactory(name="Coded")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=datatypes_source,
concept_class="Datatype",
names=[LocalizedTextFactory(name="Text")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=nametypes_source,
concept_class="NameType",
names=[
LocalizedTextFactory(name="FULLY_SPECIFIED"),
LocalizedTextFactory(name="Fully Specified")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=nametypes_source,
concept_class="NameType",
names=[
LocalizedTextFactory(name="Short"),
LocalizedTextFactory(name="SHORT")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=nametypes_source,
concept_class="NameType",
names=[
LocalizedTextFactory(name="INDEX_TERM"),
LocalizedTextFactory(name="Index Term")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=nametypes_source,
concept_class="NameType",
names=[LocalizedTextFactory(name="None")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=descriptiontypes_source,
concept_class="DescriptionType",
names=[LocalizedTextFactory(name="None")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=descriptiontypes_source,
concept_class="DescriptionType",
names=[LocalizedTextFactory(name="FULLY_SPECIFIED")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=descriptiontypes_source,
concept_class="DescriptionType",
names=[LocalizedTextFactory(name="Definition")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[
LocalizedTextFactory(name="SAME-AS"),
LocalizedTextFactory(name="Same As")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[LocalizedTextFactory(name="Is Subset of")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[LocalizedTextFactory(name="Different")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[
LocalizedTextFactory(name="BROADER-THAN"),
LocalizedTextFactory(name="Broader Than"),
LocalizedTextFactory(name="BROADER_THAN")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[
LocalizedTextFactory(name="NARROWER-THAN"),
LocalizedTextFactory(name="Narrower Than"),
LocalizedTextFactory(name="NARROWER_THAN")
])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[LocalizedTextFactory(name="Q-AND-A")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[LocalizedTextFactory(name="More specific than")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[LocalizedTextFactory(name="Less specific than")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=maptypes_source,
concept_class="MapType",
names=[LocalizedTextFactory(name="Something Else")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=locales_source,
concept_class="Locale",
names=[LocalizedTextFactory(name="en")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=locales_source,
concept_class="Locale",
names=[LocalizedTextFactory(name="es")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=locales_source,
concept_class="Locale",
names=[LocalizedTextFactory(name="fr")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=locales_source,
concept_class="Locale",
names=[LocalizedTextFactory(name="tr")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=locales_source,
concept_class="Locale",
names=[LocalizedTextFactory(name="Abkhazian")])
ConceptFactory(version=HEAD,
updated_by=user,
parent=locales_source,
concept_class="Locale",
names=[LocalizedTextFactory(name="English")])
def test_names_for_default_locale(self):
es_locale = LocalizedTextFactory(locale='es', name='Not English')
en_locale = LocalizedTextFactory(locale='en', name='English')
concept = ConceptFactory(names=(es_locale, en_locale))
self.assertEqual(concept.names_for_default_locale, [en_locale.name])
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_display_name(self):
source = OrganizationSourceFactory(default_locale='fr',
supported_locales=['fr', 'ti'])
ch_locale = LocalizedTextFactory(locale_preferred=True, locale='ch')
en_locale = LocalizedTextFactory(locale_preferred=True, locale='en')
concept = ConceptFactory(names=[ch_locale, en_locale], parent=source)
self.assertEqual(
concept.display_name,
en_locale.name) # locale preferred order by created at desc
source.supported_locales = ['fr', 'ti', 'ch']
source.save()
self.assertEqual(
concept.display_name,
ch_locale.name) # locale preferred parent's supported locale
# taking scenarios for ciel 1366 concept
concept = ConceptFactory(
parent=source,
names=[
LocalizedTextFactory(locale_preferred=True,
locale='en',
name='MALARIA SMEAR, QUALITATIVE'),
LocalizedTextFactory(type='SHORT',
locale_preferred=False,
locale='en',
name='malaria sm, qual'),
LocalizedTextFactory(locale_preferred=False,
locale='en',
name='Jungle fever smear'),
LocalizedTextFactory(locale_preferred=True,
locale='fr',
name='FROTTIS POUR DÉTECTER PALUDISME'),
LocalizedTextFactory(locale_preferred=False,
locale='ht',
name='tès MALARYA , kalitatif'),
LocalizedTextFactory(locale_preferred=False,
locale='es',
name='frotis de malaria (cualitativo)'),
LocalizedTextFactory(locale_preferred=False,
locale='es',
name='Frotis de paludismo'),
])
source.default_locale = 'en'
source.supported_locales = ['en']
source.save()
self.assertEqual(concept.display_name, 'MALARIA SMEAR, QUALITATIVE')
source.default_locale = 'fr'
source.supported_locales = ['fr', 'en']
source.save()
self.assertEqual(concept.display_name,
'FROTTIS POUR DÉTECTER PALUDISME')
source.default_locale = 'es'
source.supported_locales = ['es']
source.save()
self.assertEqual(concept.display_name, 'Frotis de paludismo')
source.default_locale = 'ht'
source.supported_locales = ['ht', 'en']
source.save()
self.assertEqual(concept.display_name, 'tès MALARYA , kalitatif')
source.default_locale = 'ti'
source.supported_locales = ['ti']
source.save()
self.assertEqual(
concept.display_name,
'MALARIA SMEAR, QUALITATIVE') # system default locale = en
source.default_locale = 'ti'
source.supported_locales = ['ti', 'en']
source.save()
self.assertEqual(concept.display_name, 'MALARIA SMEAR, QUALITATIVE')
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.']}
)