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']) )