def test_persist_new_version(self):
source = OrganizationSourceFactory(version=HEAD)
concept = ConceptFactory(mnemonic='concept1', parent=source)
self.assertEqual(source.concepts_set.count(), 2) # parent-child
self.assertEqual(source.concepts.count(), 2)
self.assertEqual(concept.sources.count(), 1)
self.assertTrue(source.is_latest_version)
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.assertFalse(source.is_latest_version)
self.assertEqual(source.concepts_set.count(), 2) # parent-child
self.assertEqual(source.concepts.count(), 2)
self.assertTrue(version1.is_latest_version)
self.assertEqual(version1.concepts.count(), 1)
self.assertEqual(
version1.concepts.first(),
source.concepts.filter(is_latest_version=True).first())
self.assertEqual(version1.concepts_set.count(), 0) # no direct child
def setUp(self):
super().setUp()
self.organization = Organization.objects.first()
self.user = UserProfile.objects.filter(is_superuser=True).first()
self.token = self.user.get_token()
self.extras = dict(foo='bar', tao='ching')
self.source = OrganizationSourceFactory(organization=self.organization, extras=self.extras)
def test_source_version_create_positive(self):
source = OrganizationSourceFactory()
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_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)
mapping1 = MappingFactory(from_concept=concept1,
to_concept=concept2,
parent=source1)
mapping2 = MappingFactory(from_concept=concept1,
to_concept=concept3,
parent=source1)
mapping3 = MappingFactory(from_concept=concept1,
to_concept=concept3,
parent=source2)
mapping4 = MappingFactory(from_concept=concept4,
to_concept=concept1,
parent=source1)
mapping5 = MappingFactory(from_concept=concept4,
to_concept=concept1,
parent=source2)
MappingFactory(from_concept=concept1,
to_concept=concept2,
parent=source2)
mappings = concept1.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 2)
self.assertEqual(list(mappings), [mapping2, mapping1])
mappings = concept1.get_indirect_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [mapping4])
mappings = concept1.get_bidirectional_mappings()
self.assertEqual(mappings.count(), 3)
self.assertEqual(list(mappings), [mapping4, mapping2, mapping1])
mappings = concept2.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 0)
mappings = concept2.get_indirect_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [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), [mapping3])
mappings = concept4.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [mapping5])
mappings = concept4.get_indirect_mappings()
self.assertEqual(mappings.count(), 0)
def test_clear_processing(self):
source = OrganizationSourceFactory(_background_process_ids=[1, 2])
self.assertEqual(source._background_process_ids, [1, 2]) # pylint: disable=protected-access
source.clear_processing()
self.assertEqual(source._background_process_ids, []) # pylint: disable=protected-access
def test_get_version(self):
source = OrganizationSourceFactory()
source_v1 = OrganizationSourceFactory(mnemonic=source.mnemonic,
organization=source.organization,
version='v1')
self.assertEqual(Source.get_version(source.mnemonic), source)
self.assertEqual(Source.get_version(source.mnemonic, 'v1'), source_v1)
def setUp(self):
super().setUp()
self.organization = Organization.objects.first()
self.user = UserProfile.objects.filter(is_superuser=True).first()
self.token = self.user.get_token()
self.source = OrganizationSourceFactory(organization=self.organization)
self.source_v1 = OrganizationSourceFactory(
mnemonic=self.source.mnemonic, organization=self.organization, version='v1',
)
class SourceLatestVersionRetrieveUpdateViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.organization = Organization.objects.first()
self.user = UserProfile.objects.filter(is_superuser=True).first()
self.token = self.user.get_token()
self.source = OrganizationSourceFactory(organization=self.organization)
self.latest_version = OrganizationSourceFactory(
mnemonic=self.source.mnemonic,
is_latest_version=True,
organization=self.organization,
version='v1',
released=True)
def test_get_200(self):
response = self.client.get('/orgs/{}/sources/{}/latest/'.format(
self.organization.mnemonic, self.source.mnemonic),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['id'], 'v1')
self.assertEqual(response.data['uuid'], str(self.latest_version.id))
self.assertEqual(response.data['short_code'], self.source.mnemonic)
def test_put_200(self):
self.assertIsNone(self.latest_version.external_id)
external_id = '123'
response = self.client.put('/orgs/{}/sources/{}/latest/'.format(
self.organization.mnemonic, self.source.mnemonic),
dict(external_id=external_id),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['id'], 'v1')
self.assertEqual(response.data['uuid'], str(self.latest_version.id))
self.assertEqual(response.data['short_code'], self.source.mnemonic)
self.assertEqual(response.data['external_id'], external_id)
self.latest_version.refresh_from_db()
self.assertEqual(self.latest_version.external_id, external_id)
def test_put_400(self):
response = self.client.put('/orgs/{}/sources/{}/latest/'.format(
self.organization.mnemonic, self.source.mnemonic),
dict(id=None),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, {
'id':
[ErrorDetail(string='This field may not be null.', code='null')]
})
def test_export_source(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)
source_v1 = OrganizationSourceFactory(mnemonic=source.mnemonic,
organization=source.organization,
version='v1')
concept1.sources.add(source_v1)
concept2.sources.add(source_v1)
mapping.sources.add(source_v1)
export_source(source_v1.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, {
**SourceVersionExportSerializer(source_v1).data, 'concepts':
ANY,
'mappings': ANY
})
exported_concepts = exported_data['concepts']
expected_concepts = ConceptVersionDetailSerializer(
[concept2, concept1], 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], many=True).data
self.assertEqual(len(exported_mappings), 1)
self.assertEqual(expected_mappings, exported_mappings)
s3_upload_key = source_v1.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_child_count_updates(self):
source = OrganizationSourceFactory(version=HEAD)
self.assertEqual(source.active_concepts, 0)
concept = ConceptFactory(sources=[source], parent=source)
source.save()
self.assertEqual(source.num_concepts, 1)
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_source_version_create_positive__same_version(self):
source = OrganizationSourceFactory()
self.assertEqual(source.num_versions, 1)
OrganizationSourceFactory(
name='version1', mnemonic=source.mnemonic, version='version1', organization=source.organization
)
source2 = OrganizationSourceFactory()
self.assertEqual(source2.num_versions, 1)
OrganizationSourceFactory(
name='version1', mnemonic=source2.mnemonic, version='version1', organization=source2.organization
)
self.assertEqual(source2.num_versions, 2)
def test_persist_changes_negative__repeated_mnemonic(self):
kwargs = {
'parent_resource': self.user
}
source1 = OrganizationSourceFactory(organization=None, user=self.user, mnemonic='source-1', version=HEAD)
source2 = OrganizationSourceFactory(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_concept_access_changes_with_source(self):
source = OrganizationSourceFactory(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_add_processing(self):
source = OrganizationSourceFactory()
self.assertEqual(source._background_process_ids, []) # pylint: disable=protected-access
source.add_processing('123')
self.assertEqual(source._background_process_ids, ['123']) # pylint: disable=protected-access
source.add_processing('123')
self.assertEqual(source._background_process_ids, ['123', '123']) # pylint: disable=protected-access
source.add_processing('abc')
self.assertEqual(source._background_process_ids, ['123', '123', 'abc']) # pylint: disable=protected-access
source.refresh_from_db()
self.assertEqual(source._background_process_ids, ['123', '123', 'abc']) # pylint: disable=protected-access
def test_a_preferred_name_can_not_be_a_short_name(self):
source = OrganizationSourceFactory(
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="ShortName",
locale_preferred=True,
type="Short",
locale='fr'),
LocalizedTextFactory.build(name='Fully Specified Name'),
]))
self.assertEqual(
concept.errors,
dict(names=[
OPENMRS_SHORT_NAME_CANNOT_BE_PREFERRED +
': ShortName (locale: fr, preferred: yes)'
]))
def test_unique_preferred_name_per_locale_within_concept_negative(self):
source = OrganizationSourceFactory(
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_concepts_should_have_unique_fully_specified_name_per_locale(self):
name_fully_specified1 = LocalizedTextFactory.build(
name='FullySpecifiedName1')
source = OrganizationSourceFactory(
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_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 = OrganizationSourceFactory(
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 setUp(self):
self.organization = Organization.objects.first()
self.user = UserProfile.objects.filter(is_superuser=True).first()
self.token = self.user.get_token()
self.source = OrganizationSourceFactory(organization=self.organization)
self.concept_payload = {
'datatype':
'Coded',
'concept_class':
'Procedure',
'extras': {
'foo': 'bar'
},
'descriptions': [{
'locale': 'en',
'locale_preferred': True,
'description': 'c1 desc',
'description_type': 'None'
}],
'external_id':
'',
'id':
'c1',
'names': [{
'locale': 'en',
'locale_preferred': True,
'name': 'c1 name',
'name_type': 'Fully Specified'
}]
}
def test_get_200_zip(self):
response = self.client.get(self.organization.sources_url,
HTTP_COMPRESS='true',
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/zip')
content = json.loads(
zipfile.ZipFile(response.rendered_content.filelike).read(
'export.json').decode('utf-8'))
self.assertEqual(content, [])
source = OrganizationSourceFactory(organization=self.organization)
response = self.client.get(
self.organization.sources_url + '?verbose=true',
HTTP_COMPRESS='true',
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/zip')
content = json.loads(
zipfile.ZipFile(response.rendered_content.filelike).read(
'export.json').decode('utf-8'))
self.assertEqual(content,
SourceDetailSerializer([source], many=True).data)
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.get_latest_version().uri)
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)
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.get_latest_version().uri)
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_seed_references(self):
collection1 = OrganizationCollectionFactory()
collection2 = OrganizationCollectionFactory(
version='v1',
mnemonic=collection1.mnemonic,
organization=collection1.organization)
self.assertTrue(collection1.is_head)
self.assertFalse(collection2.is_head)
source = OrganizationSourceFactory()
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_seed_children_task_with_export(self, export_source_task, index_children_mock):
source = OrganizationSourceFactory()
ConceptFactory(parent=source)
MappingFactory(parent=source)
source_v1 = OrganizationSourceFactory(organization=source.organization, version='v1', mnemonic=source.mnemonic)
self.assertEqual(source_v1.concepts.count(), 0)
self.assertEqual(source_v1.mappings.count(), 0)
seed_children('source', source_v1.id) # pylint: disable=no-value-for-parameter
self.assertEqual(source_v1.concepts.count(), 1)
self.assertEqual(source_v1.mappings.count(), 1)
export_source_task.delay.assert_called_once_with(source_v1.id)
index_children_mock.assert_called_once()
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')
mapping.populate_fields_from_relations({})
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.populate_fields_from_relations({})
mapping.clean()
def test_single_mapping_between_concepts(self):
source = OrganizationSourceFactory(
version=HEAD,
custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept1 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
concept2 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
mapping1 = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2)
mapping1.clean()
mapping1.save()
mapping2 = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2)
with self.assertRaises(ValidationError) as ex:
mapping2.clean()
self.assertEqual(
ex.exception.messages,
['There can be only one mapping between two concepts'])
mapping3 = MappingFactory.build(parent=source,
to_concept=concept2,
from_concept=concept1)
mapping3.clean()
def test_no_more_than_one_short_name_per_locale(self):
source = OrganizationSourceFactory(
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_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.get_latest_version().uri,
mapping.get_latest_version().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.get_latest_version().uri)
def test_specifier_should_initialize_openmrs_validator_with_reference_values(
self):
source = OrganizationSourceFactory(
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']))
def test_put_200(self):
source = OrganizationSourceFactory(organization=self.organization)
self.assertTrue(source.is_head)
self.assertEqual(source.versions.count(), 1)
sources_url = "/orgs/{}/sources/{}/".format(self.organization.mnemonic, source.mnemonic)
response = self.client.put(
sources_url,
{'full_name': 'Full name'},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertListEqual(
list(response.data.keys()),
[
'type', 'uuid', 'id', 'short_code', 'name', 'full_name', 'description', 'source_type',
'custom_validation_schema', 'public_access', 'default_locale', 'supported_locales', 'website',
'url', 'owner', 'owner_type', 'owner_url', 'versions', 'created_on', 'updated_on', 'created_by',
'updated_by', 'extras', 'external_id', 'versions_url', 'version', 'concepts_url', 'mappings_url',
'active_concepts', 'active_mappings',
]
)
source = Source.objects.last()
self.assertTrue(source.is_head)
self.assertEqual(source.versions.count(), 1)
self.assertEqual(response.data['full_name'], source.full_name)
self.assertEqual(response.data['full_name'], 'Full name')
