def test_source_version_create_positive(self):
source = SourceFactory()
self.assertEqual(source.num_versions, 1)
source_version = Source(name='version1',
mnemonic=source.mnemonic,
version='version1',
released=True,
created_by=source.created_by,
updated_by=source.updated_by,
organization=source.organization)
source_version.full_clean()
source_version.save()
self.assertEqual(source.num_versions, 2)
self.assertEqual(source.organization.mnemonic,
source_version.parent_resource)
self.assertEqual(source.organization.resource_type,
source_version.parent_resource_type)
self.assertEqual(source_version, source.get_latest_version())
self.assertEqual(
source_version.uri,
'/orgs/{org}/sources/{source}/{version}/'.format(
org=source_version.organization.mnemonic,
source=source_version.mnemonic,
version=source_version.version))
def test_get_latest_versions_for_queryset(self):
self.assertEqual(Concept.get_latest_versions_for_queryset(Concept.objects.none()).count(), 0)
source1 = SourceFactory()
concept1_latest = ConceptFactory(parent=source1, mnemonic='common-name-1')
ConceptFactory(version='v1', parent=source1, is_latest_version=False, mnemonic=concept1_latest.mnemonic)
concept2_latest = ConceptFactory(parent=source1)
ConceptFactory(version='v1', parent=source1, is_latest_version=False, mnemonic=concept2_latest.mnemonic)
concept3_latest = ConceptFactory(parent=source1, mnemonic='common-name-2')
ConceptFactory(version='v1', parent=source1, is_latest_version=False, mnemonic=concept3_latest.mnemonic)
source2 = SourceFactory()
concept4_latest = ConceptFactory(parent=source2, mnemonic='common-name-1')
ConceptFactory(version='v1', parent=source2, is_latest_version=False, mnemonic=concept4_latest.mnemonic)
concept5_latest = ConceptFactory(parent=source2)
ConceptFactory(version='v1', parent=source2, is_latest_version=False, mnemonic=concept5_latest.mnemonic)
concept6_latest = ConceptFactory(parent=source2, mnemonic='common-name-2')
ConceptFactory(version='v1', parent=source2, is_latest_version=False, mnemonic=concept6_latest.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_child_count_updates(self):
source = SourceFactory(version=HEAD)
self.assertEqual(source.active_concepts, 0)
concept = ConceptFactory(sources=[source], parent=source)
source.save()
self.assertEqual(source.active_concepts, 1)
self.assertEqual(source.last_concept_update, concept.updated_at)
self.assertEqual(source.last_child_update, source.last_concept_update)
def test_concept_access_changes_with_source(self):
source = SourceFactory(version=HEAD)
self.assertEqual(source.public_access, ACCESS_TYPE_EDIT)
concept = ConceptFactory(parent=source, public_access=ACCESS_TYPE_EDIT)
self.assertEqual(concept.public_access, ACCESS_TYPE_EDIT)
source.public_access = ACCESS_TYPE_VIEW
source.save()
concept.refresh_from_db()
self.assertEqual(source.public_access, ACCESS_TYPE_VIEW)
self.assertEqual(source.public_access, concept.public_access)
def test_source_version_create_positive__same_version(self):
source = SourceFactory()
self.assertEqual(source.num_versions, 1)
SourceFactory(name='version1',
mnemonic=source.mnemonic,
version='version1',
organization=source.organization)
source2 = SourceFactory()
self.assertEqual(source2.num_versions, 1)
SourceFactory(name='version1',
mnemonic=source2.mnemonic,
version='version1',
organization=source2.organization)
self.assertEqual(source2.num_versions, 2)
def test_unretire(self):
source = SourceFactory(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)]
})
self.assertEqual(concept.versions.count(), 1)
self.assertTrue(concept.retired)
self.assertTrue(concept.is_head)
concept.unretire(concept.created_by, 'World needs you!') # concept will become old/prev version
concept.refresh_from_db()
self.assertFalse(concept.is_head)
self.assertEqual(concept.versions.count(), 2)
self.assertTrue(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_duplicate_preferred_name_per_source_should_fail(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept1 = 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='en',
locale_preferred=True, type='Fully Specified'
),
]
)
)
concept2 = Concept.persist_new(
dict(
mnemonic='concept2', version=HEAD, name='concept2', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(
name='Concept Non Unique Preferred Name', locale='en', locale_preferred=True, type='None'
),
LocalizedTextFactory.build(
name='any name', locale='en', locale_preferred=False, type='Fully Specified'
),
]
)
)
self.assertEqual(concept1.errors, {})
self.assertEqual(
concept2.errors,
dict(names=[OPENMRS_PREFERRED_NAME_UNIQUE_PER_SOURCE_LOCALE +
': Concept Non Unique Preferred Name (locale: en, preferred: yes)'])
)
def test_seed_references(self):
collection1 = CollectionFactory()
collection2 = CollectionFactory(version='v1',
mnemonic=collection1.mnemonic,
organization=collection1.organization)
self.assertTrue(collection1.is_head)
self.assertFalse(collection2.is_head)
source = SourceFactory()
concept = ConceptFactory(parent=source, sources=[source])
concept_expression = concept.uri
collection1.add_references([concept_expression])
self.assertEqual(collection1.references.count(), 1)
self.assertEqual(collection2.references.count(), 0)
collection2.seed_references()
self.assertEqual(collection1.references.count(), 1)
self.assertEqual(collection2.references.count(), 1)
self.assertEqual(collection1.references.first().expression,
collection2.references.first().expression)
self.assertNotEqual(collection1.references.first().id,
collection2.references.first().id)
def test_persist_changes_negative__repeated_mnemonic(self):
kwargs = {'parent_resource': self.user}
source1 = SourceFactory(organization=None,
user=self.user,
mnemonic='source-1',
version=HEAD)
source2 = SourceFactory(organization=None,
user=self.user,
mnemonic='source-2',
version=HEAD)
source2.mnemonic = source1.mnemonic
with transaction.atomic():
errors = Source.persist_changes(source2, self.user, **kwargs)
self.assertEqual(len(errors), 1)
self.assertTrue('__all__' in errors)
def test_persist_clone(self):
es_locale = LocalizedTextFactory(locale='es', name='Not English')
en_locale = LocalizedTextFactory(locale='en', name='English')
source_head = SourceFactory(version=HEAD)
source_version0 = SourceFactory(
version='v0', mnemonic=source_head.mnemonic, organization=source_head.organization
)
self.assertEqual(source_head.versions.count(), 2)
concept = ConceptFactory(
descriptions=(es_locale, en_locale),
names=(en_locale,),
sources=(source_version0,),
parent=source_version0
)
cloned_concept = Concept.version_for_concept(concept, 'v1', source_version0)
self.assertEqual(
Concept.persist_clone(cloned_concept),
dict(version_created_by='Must specify which user is attempting to create a new concept version.')
)
self.assertEqual(Concept.persist_clone(cloned_concept, concept.created_by), {})
persisted_concept = Concept.objects.filter(
mnemonic=cloned_concept.mnemonic, version=cloned_concept.version
).first()
self.assertEqual(persisted_concept.names.count(), 1)
self.assertEqual(persisted_concept.descriptions.count(), 2)
self.assertEqual(persisted_concept.parent, source_version0)
self.assertEqual(persisted_concept.sources.count(), 2)
self.assertEqual(source_head.concepts.first().id, persisted_concept.id)
self.assertEqual(
persisted_concept.uri,
'/orgs/{}/sources/{}/{}/concepts/{}/{}/'.format(
source_version0.organization.mnemonic, source_version0.mnemonic, source_version0.version,
persisted_concept.mnemonic, persisted_concept.version
)
)
self.assertEqual(
persisted_concept.version_url, persisted_concept.uri
)
def test_source_version_create_negative__same_version(self):
source = SourceFactory()
self.assertEqual(source.num_versions, 1)
SourceFactory(name='version1',
mnemonic=source.mnemonic,
version='version1',
organization=source.organization)
self.assertEqual(source.num_versions, 2)
with transaction.atomic():
source_version = Source(name='version1',
version='version1',
mnemonic=source.mnemonic,
organization=source.organization)
with self.assertRaises(IntegrityError):
source_version.full_clean()
source_version.save()
self.assertEqual(source.num_versions, 2)
def test_version_for_concept(self):
concept = ConceptFactory(released=True)
source = SourceFactory()
concept_version = Concept.version_for_concept(concept, 'v1.0', source)
self.assertEqual(concept_version.parent, source)
self.assertEqual(concept_version.version, 'v1.0')
self.assertEqual(concept_version.created_by_id, concept.created_by_id)
self.assertEqual(concept_version.updated_by_id, concept.updated_by_id)
self.assertEqual(concept_version.mnemonic, concept.mnemonic)
self.assertFalse(concept_version.released)
def test_source_version_delete(self):
source = SourceFactory(version=HEAD)
concept = ConceptFactory(mnemonic='concept1',
version=HEAD,
sources=[source],
parent=source)
self.assertTrue(source.is_latest_version)
self.assertEqual(concept.sources.count(), 1)
version1 = SourceFactory.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.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.sources.count(), 1)
with self.assertRaises(ValidationError) as ex:
source.delete()
self.assertEqual(ex.exception.message_dict, {
'detail': ['Cannot delete only version.'],
})
def test_persist_new_version(self):
source = SourceFactory(version=HEAD)
concept = ConceptFactory(mnemonic='concept1', parent=source)
self.assertEqual(source.concepts_set.count(), 1) # parent-child
self.assertEqual(source.concepts.count(), 1)
self.assertEqual(concept.sources.count(), 1)
self.assertTrue(source.is_latest_version)
version1 = SourceFactory.build(name='version1',
version='v1',
mnemonic=source.mnemonic,
organization=source.organization)
Source.persist_new_version(version1, source.created_by)
source.refresh_from_db()
self.assertFalse(source.is_latest_version)
self.assertEqual(source.concepts_set.count(), 1) # parent-child
self.assertEqual(source.concepts.count(), 1)
self.assertTrue(version1.is_latest_version)
self.assertEqual(version1.concepts.count(), 1)
self.assertEqual(version1.concepts_set.count(), 0) # no direct child
def test_data_type_is_valid_attribute_negative(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept = Concept.persist_new(
dict(
mnemonic='concept1', version=HEAD, name='concept1', parent=source,
concept_class='Diagnosis', datatype='XYZWERRTR',
names=[LocalizedTextFactory.build(name='Grip', locale='es', locale_preferred=True)]
)
)
self.assertEqual(
concept.errors,
dict(data_type=[OPENMRS_DATATYPE])
)
def test_persist_clone(self):
source_head = SourceFactory(version=HEAD)
source_version0 = SourceFactory(
version='v0', mnemonic=source_head.mnemonic, organization=source_head.organization
)
self.assertEqual(source_head.versions.count(), 2)
mapping = MappingFactory(parent=source_version0)
cloned_mapping = mapping.clone(mapping.created_by)
self.assertEqual(
Mapping.persist_clone(cloned_mapping),
dict(version_created_by='Must specify which user is attempting to create a new mapping version.')
)
self.assertEqual(Mapping.persist_clone(cloned_mapping, mapping.created_by), {})
persisted_mapping = Mapping.objects.filter(
id=cloned_mapping.id, version=cloned_mapping.version
).first()
self.assertEqual(mapping.versions.count(), 2)
self.assertNotEqual(mapping.id, persisted_mapping.id)
self.assertEqual(persisted_mapping.from_concept_id, mapping.from_concept_id)
self.assertEqual(persisted_mapping.to_concept_id, mapping.to_concept_id)
self.assertEqual(persisted_mapping.parent, source_version0)
self.assertEqual(persisted_mapping.sources.count(), 2)
self.assertEqual(source_head.mappings.first().id, persisted_mapping.id)
self.assertEqual(
persisted_mapping.uri,
'/orgs/{}/sources/{}/{}/mappings/{}/{}/'.format(
source_version0.organization.mnemonic, source_version0.mnemonic, source_version0.version,
persisted_mapping.mnemonic, persisted_mapping.version
)
)
self.assertEqual(
persisted_mapping.version_url, persisted_mapping.uri
)
def test_locale_preferred_name_uniqueness_doesnt_apply_to_shorts(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(name="mg", locale='en', locale_preferred=True),
LocalizedTextFactory.build(name='mg', locale='en', type='Short'),
]
)
)
self.assertEqual(concept.errors, {})
self.assertIsNotNone(concept.id)
def test_description_locale_is_valid_attribute_negative(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept = Concept.persist_new(
dict(
mnemonic='concept1', version=HEAD, name='concept1', parent=source,
concept_class='Diagnosis', datatype='None',
names=[LocalizedTextFactory.build(locale_preferred=True)],
descriptions=[LocalizedTextFactory.build(locale_preferred=True, locale='FOOBAR')]
)
)
self.assertEqual(
concept.errors,
dict(descriptions=[OPENMRS_DESCRIPTION_LOCALE])
)
def test_a_name_can_be_equal_to_a_short_name(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(name="aName", type=SHORT),
LocalizedTextFactory.build(name='aName'),
]
)
)
self.assertEqual(concept.errors, {})
self.assertIsNotNone(concept.id)
def test_a_preferred_name_can_not_be_an_index_search_term(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(name="IndexTermName", locale_preferred=True, type=INDEX_TERM),
LocalizedTextFactory.build(name='Fully Specified Name'),
]
)
)
self.assertEqual(
concept.errors,
dict(names=[OPENMRS_SHORT_NAME_CANNOT_BE_PREFERRED + ': IndexTermName (locale: en, preferred: yes)'])
)
def test_source_active_inactive_should_affect_children(self):
source = SourceFactory(is_active=True)
concept = ConceptFactory(parent=source, is_active=True)
source.is_active = False
source.save()
concept.refresh_from_db()
self.assertFalse(source.is_active)
self.assertFalse(concept.is_active)
source.is_active = True
source.save()
concept.refresh_from_db()
self.assertTrue(source.is_active)
self.assertTrue(concept.is_active)
def test_a_name_should_be_unique(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(name="aName"),
LocalizedTextFactory.build(name='aName'),
]
)
)
self.assertEqual(
concept.errors,
dict(names=[OPENMRS_NAMES_EXCEPT_SHORT_MUST_BE_UNIQUE])
)
def test_at_least_one_fully_specified_name_per_concept_negative(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(name='Fully Specified Name 1', locale='tr', type='Short'),
LocalizedTextFactory.build(name='Fully Specified Name 2', locale='en', type='Short')
]
)
)
self.assertEqual(
concept.errors,
dict(names=[OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME])
)
def test_add_references(self):
collection = CollectionFactory()
self.assertEqual(collection.concepts.count(), 0)
self.assertEqual(collection.references.count(), 0)
source = SourceFactory()
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)
def test_concept_should_have_exactly_one_preferred_name_per_locale(self):
name_en1 = LocalizedTextFactory.build(name='PreferredName1', locale_preferred=True)
name_en2 = LocalizedTextFactory.build(name='PreferredName2', locale_preferred=True)
name_tr = LocalizedTextFactory.build(name='PreferredName3', locale="tr", locale_preferred=True)
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[name_en1, name_en2, name_tr]
)
)
self.assertEqual(
concept.errors,
dict(names=[OPENMRS_MUST_HAVE_EXACTLY_ONE_PREFERRED_NAME + ': PreferredName2 (locale: en, preferred: yes)'])
)
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_no_more_than_one_short_name_per_locale(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
concept = Concept.persist_new(
dict(
mnemonic='concept', version=HEAD, name='concept', parent=source,
concept_class='Diagnosis', datatype='None', names=[
LocalizedTextFactory.build(name="fully specified name1", locale='en', type='Short'),
LocalizedTextFactory.build(name='fully specified name2', locale='en', type='Short'),
LocalizedTextFactory.build(name='fully specified name3', locale='fr'),
]
)
)
self.assertEqual(
concept.errors,
dict(names=[OPENMRS_NO_MORE_THAN_ONE_SHORT_NAME_PER_LOCALE +
': fully specified name2 (locale: en, preferred: no)'])
)
def test_persist_new(self):
source = SourceFactory(version=HEAD)
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = Mapping.persist_new({
**factory.build(dict, FACTORY_CLASS=MappingFactory), 'from_concept': concept1, 'to_concept': concept2,
'parent_id': source.id
}, source.created_by)
self.assertEqual(mapping.errors, {})
self.assertIsNotNone(mapping.id)
self.assertEqual(mapping.version, str(mapping.id))
self.assertEqual(source.mappings_set.count(), 1)
self.assertEqual(source.mappings.count(), 1)
self.assertEqual(
mapping.uri,
'/orgs/{}/sources/{}/mappings/{}/{}/'.format(
source.organization.mnemonic, source.mnemonic, mapping.mnemonic, mapping.id
)
)
def test_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_specifier_should_initialize_openmrs_validator_with_reference_values(self):
source = SourceFactory(custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS, version=HEAD)
expected_reference_values = {
'DescriptionTypes': ['None', 'FULLY_SPECIFIED', 'Definition'],
'Datatypes': ['None', 'N/A', 'Numeric', 'Coded', 'Text'],
'Classes': ['Diagnosis', 'Drug', 'Test', 'Procedure'],
'Locales': ['en', 'es', 'fr', 'tr', 'Abkhazian', 'English'],
'NameTypes': ['FULLY_SPECIFIED', 'Fully Specified', 'Short', 'SHORT', 'INDEX_TERM', 'Index Term', 'None']}
validator = ValidatorSpecifier().with_validation_schema(
CUSTOM_VALIDATION_SCHEMA_OPENMRS
).with_repo(source).with_reference_values().get()
actual_reference_values = validator.reference_values
self.assertEqual(sorted(expected_reference_values['Datatypes']), sorted(actual_reference_values['Datatypes']))
self.assertEqual(sorted(expected_reference_values['Classes']), sorted(actual_reference_values['Classes']))
self.assertEqual(sorted(expected_reference_values['Locales']), sorted(actual_reference_values['Locales']))
self.assertEqual(sorted(expected_reference_values['NameTypes']), sorted(actual_reference_values['NameTypes']))
self.assertEqual(
sorted(expected_reference_values['DescriptionTypes']), sorted(actual_reference_values['DescriptionTypes'])
)
