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