def create_sources(org, user): sources = dict() kwargs = {'parent_resource': org} for source_name in [ 'Locales', 'Classes', 'Datatypes', 'DescriptionTypes', 'NameTypes', 'MapTypes' ]: if Source.objects.filter(organization=org, mnemonic=source_name, version=HEAD).exists(): source = Source.objects.get(organization=org, mnemonic=source_name, version=HEAD) else: source = Source(name=source_name, mnemonic=source_name, full_name=source_name, organization=org, created_by=user, default_locale='en', supported_locales=['en'], updated_by=user, version=HEAD) Source.persist_new(source, user, **kwargs) sources[source_name] = source return sources
def test_owner(self): org = Organization(id=123) user = UserProfile(id=123) self.assertIsNone(Mapping().owner) self.assertEqual(Mapping(parent=Source(organization=org)).owner, org) self.assertEqual(Mapping(parent=Source(user=user)).owner, user)
def test_persist_changes_positive(self): kwargs = { 'parent_resource': self.user } errors = Source.persist_new(self.new_source, self.user, **kwargs) self.assertEqual(len(errors), 0) saved_source = Source.objects.get(name=self.new_source.name) name = saved_source.name self.new_source.name = "%s_prime" % name self.new_source.source_type = 'Reference' errors = Source.persist_changes(self.new_source, self.user, **kwargs) updated_source = Source.objects.get(mnemonic=self.new_source.mnemonic) self.assertEqual(len(errors), 0) self.assertEqual(updated_source.num_versions, 1) self.assertEqual(updated_source.head, updated_source) self.assertEqual(updated_source.name, self.new_source.name) self.assertEqual(updated_source.source_type, 'Reference') self.assertEqual( updated_source.uri, '/users/{username}/sources/{source}/'.format(username=self.user.username, source=updated_source.mnemonic) )
def test_owner_type(self): org = Organization(id=123, mnemonic='org') user = UserProfile(id=123, username='******') self.assertIsNone(Mapping().owner_type) self.assertEqual(Mapping(parent=Source(organization=org)).owner_type, 'Organization') self.assertEqual(Mapping(parent=Source(user=user)).owner_type, 'User')
def test_source_version_delete(self): source = OrganizationSourceFactory(version=HEAD) concept = ConceptFactory( mnemonic='concept1', version=HEAD, sources=[source], parent=source ) self.assertTrue(source.is_latest_version) self.assertEqual(concept.get_latest_version().sources.count(), 1) 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.assertEqual(concept.get_latest_version().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.get_latest_version().sources.count(), 1)
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 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 test_head_from_uri(self): source = OrganizationSourceFactory(version='HEAD') self.assertEqual(Source.head_from_uri('').count(), 0) self.assertEqual(Source.head_from_uri('foobar').count(), 0) queryset = Source.head_from_uri(source.uri) self.assertEqual(queryset.count(), 1) self.assertEqual(queryset.first(), source)
def prepare_object(self, validated_data, instance=None): source = instance if instance else Source() source.version = validated_data.get('version', source.version) or HEAD source.mnemonic = validated_data.get(self.Meta.lookup_field, source.mnemonic) source.public_access = validated_data.get('public_access', source.public_access or DEFAULT_ACCESS_TYPE) source.default_locale = validated_data.get('default_locale', source.default_locale or DEFAULT_LOCALE) supported_locales = validated_data.get('supported_locales') if not supported_locales: supported_locales = source.supported_locales if supported_locales and isinstance(supported_locales, str): supported_locales = supported_locales.split(',') source.supported_locales = supported_locales or [source.default_locale] for attr in [ 'website', 'description', 'source_type', 'name', 'custom_validation_schema', 'retired', 'released', 'organization', 'user', 'organization_id', 'user_id', 'external_id', 'extras', 'experimental', 'case_sensitive', 'collection_reference', 'hierarchy_meaning', 'compositional', 'version_needed', 'canonical_url', 'identifier', 'publisher', 'contact', 'jurisdiction', 'purpose', 'copyright', 'content_type', 'revision_date', 'text', 'meta', ]: setattr(source, attr, validated_data.get(attr, get(source, attr))) source.full_name = validated_data.get('full_name', source.full_name) or source.name if 'hierarchy_root' in validated_data or 'hierarchy_root_url' in validated_data: hierarchy_root_url = get(validated_data, 'hierarchy_root.url') or get( validated_data, 'hierarchy_root_url') from core.concepts.models import Concept source.hierarchy_root = Concept.objects.filter( uri=hierarchy_root_url).first() if hierarchy_root_url else None return source
def test_resource_uri(self): self.assertEqual( Pin(resource=Organization(uri='/orgs/foo/')).resource_uri, '/orgs/foo/') self.assertEqual( Pin(resource=Source(uri='/orgs/foo/sources/bar/')).resource_uri, '/orgs/foo/sources/bar/')
def update(self, instance, validated_data): original_schema = instance.custom_validation_schema source = self.prepare_object(validated_data, instance) user = self.context['request'].user errors = Source.persist_changes(source, user, original_schema) self._errors.update(errors) return source
def update(self, instance, validated_data): from core.concepts.models import Concept from core.sources.models import Source instance.extras = validated_data.get('extras', instance.extras) instance.external_id = validated_data.get('external_id', instance.external_id) instance.comment = validated_data.get( 'update_comment') or validated_data.get('comment') instance.retired = validated_data.get('retired', instance.retired) from_concept_url = validated_data.get('from_concept_url', None) to_concept_url = validated_data.get('to_concept_url', None) to_source_url = validated_data.get('to_source_url', None) if from_concept_url: instance.from_concept = Concept.from_uri_queryset( from_concept_url).first() if to_concept_url: instance.to_concept = Concept.from_uri_queryset( to_concept_url).first() if to_source_url: instance.to_source = Source.head_from_uri(to_source_url).first() instance.mnemonic = validated_data.get('mnemonic', instance.mnemonic) instance.map_type = validated_data.get('map_type', instance.map_type) instance.to_concept_code = validated_data.get('to_concept_code', instance.to_concept_code) instance.to_concept_name = validated_data.get('to_concept_name', instance.to_concept_name) errors = Mapping.persist_clone(instance, self.context.get('request').user) if errors: self._errors.update(errors) return instance
def test_new_version_should_not_affect_last_child_update(self): source = OrganizationSourceFactory(version=HEAD) source_updated_at = source.updated_at source_last_child_update = source.last_child_update self.assertIsNotNone(source.id) self.assertEqual(source_updated_at, source_last_child_update) concept = ConceptFactory(sources=[source], parent=source) source.refresh_from_db() self.assertEqual(source.updated_at, source_updated_at) self.assertEqual(source.last_child_update, concept.updated_at) self.assertNotEqual(source.last_child_update, source_updated_at) self.assertNotEqual(source.last_child_update, source_last_child_update) source_last_child_update = source.last_child_update source_v1 = OrganizationSourceFactory.build(version='v1', mnemonic=source.mnemonic, organization=source.parent) Source.persist_new_version(source_v1, source.created_by) source_v1 = source.versions.filter(version='v1').first() source.refresh_from_db() self.assertIsNotNone(source_v1.id) self.assertEqual(source.last_child_update, source_last_child_update) self.assertEqual(source.updated_at, source_updated_at) source_v1_updated_at = source_v1.updated_at source_v1_last_child_update = source_v1.last_child_update source_v2 = OrganizationSourceFactory.build(version='v2', mnemonic=source.mnemonic, organization=source.parent) Source.persist_new_version(source_v2, source.created_by) source_v2 = source.versions.filter(version='v2').first() source.refresh_from_db() source_v1.refresh_from_db() self.assertIsNotNone(source_v2.id) self.assertEqual(source.last_child_update, source_last_child_update) self.assertEqual(source.updated_at, source_updated_at) self.assertEqual(source_v1.last_child_update, source_v1_last_child_update) self.assertEqual(source_v1.updated_at, source_v1_updated_at)
def set_parent_resource(self): from core.sources.models import Source source = self.kwargs.pop('source', None) source_version = self.kwargs.pop('version', HEAD) parent_resource = None if source: parent_resource = Source.get_version(source, source_version) self.kwargs['parent_resource'] = self.parent_resource = parent_resource
def test_persist_new_negative__no_owner(self): kwargs = {'parent_resource': self.user} errors = Source.persist_new(self.new_source, None, **kwargs) self.assertEqual(errors, {'created_by': 'Creator cannot be None.'}) self.assertFalse( Source.objects.filter(name=self.new_source.name).exists())
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 get_queryset(self): queryset = Source.get_base_queryset( compact_dict_by_values(self.get_filter_params())).select_related( 'user', 'organization') if self.is_verbose(): queryset = queryset.select_related('created_by', 'updated_by') return queryset
def test_persist_new_negative__no_name(self): kwargs = {'parent_resource': self.user} self.new_source.name = None errors = Source.persist_new(self.new_source, self.user, **kwargs) self.assertEqual(errors, {'name': ['This field cannot be null.']}) self.assertFalse( Source.objects.filter(name=self.new_source.name).exists())
def prepare_object(self, validated_data, instance=None): source = instance if instance else Source() source.version = validated_data.get('version', source.version) or HEAD source.mnemonic = validated_data.get(self.Meta.lookup_field, source.mnemonic) source.name = validated_data.get('name', source.name) source.full_name = validated_data.get('full_name', source.full_name) or source.name source.description = validated_data.get('description', source.description) source.source_type = validated_data.get('source_type', source.source_type) source.custom_validation_schema = validated_data.get( 'custom_validation_schema', source.custom_validation_schema) source.public_access = validated_data.get( 'public_access', source.public_access or DEFAULT_ACCESS_TYPE) source.default_locale = validated_data.get( 'default_locale', source.default_locale or DEFAULT_LOCALE) source.website = validated_data.get('website', source.website) supported_locales = validated_data.get('supported_locales') if not supported_locales: supported_locales = source.supported_locales if supported_locales and isinstance(supported_locales, str): supported_locales = supported_locales.split(',') source.supported_locales = supported_locales or [source.default_locale] source.extras = validated_data.get('extras', source.extras) source.external_id = validated_data.get('external_id', source.external_id) source.user_id = validated_data.get('user_id', source.user_id) source.organization_id = validated_data.get('organization_id', source.organization_id) source.user = validated_data.get('user', source.user) source.organization = validated_data.get('organization', source.organization) source.released = validated_data.get('released', source.released) source.retired = validated_data.get('retired', source.retired) source.canonical_url = validated_data.get('canonical_url', source.canonical_url) source.identifier = validated_data.get('identifier', source.identifier) source.publisher = validated_data.get('publisher', source.publisher) source.contact = validated_data.get('contact', source.contact) source.jurisdiction = validated_data.get('jurisdiction', source.jurisdiction) source.purpose = validated_data.get('purpose', source.purpose) source.copyright = validated_data.get('copyright', source.copyright) source.content_type = validated_data.get('content_type', source.content_type) source.revision_date = validated_data.get('revision_date', source.revision_date) source.text = validated_data.get('text', source.text) return source
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_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 set_parent_resource(self): from core.sources.models import Source source = self.kwargs.pop('source', None) source_version = self.kwargs.pop('version', HEAD) parent_resource = None if 'org' in self.kwargs: filters = dict(organization__mnemonic=self.kwargs['org']) else: username = self.request.user.username if self.user_is_self else self.kwargs.get('user') filters = dict(user__username=username) if source: parent_resource = Source.get_version(source, source_version, filters) self.kwargs['parent_resource'] = self.parent_resource = parent_resource
def test_get_to_source(self): mapping = Mapping() self.assertIsNone(mapping.get_to_source()) source = Source(id=123) mapping = Mapping(to_source=source) self.assertEqual(mapping.get_to_source(), source) concept = ConceptFactory() mapping = Mapping(to_concept=concept) self.assertEqual(mapping.get_to_source(), concept.parent)
def get_kwargs_filters(self): filters = self.get_facet_filters_from_kwargs() is_source_child_document_model = self.is_source_child_document_model() is_version_specified = 'version' in self.kwargs is_collection_specified = 'collection' in self.kwargs is_source_specified = 'source' in self.kwargs if is_version_specified and is_source_specified: filters['source_version'] = self.kwargs['version'] if is_version_specified and is_collection_specified: filters['collection_version'] = self.kwargs['version'] if is_source_child_document_model: if is_version_specified: container_version = self.kwargs['version'] is_latest_released = container_version == LATEST if is_latest_released: params = dict( user__username=self.kwargs.get('user'), organization__mnemonic=self.kwargs.get('org')) if is_source_specified: from core.sources.models import Source latest_released_version = Source.find_latest_released_version_by( { **params, 'mnemonic': self.kwargs['source'] }) filters['source_version'] = get( latest_released_version, 'version') elif is_collection_specified: from core.collections.models import Collection latest_released_version = Collection.find_latest_released_version_by( { **params, 'mnemonic': self.kwargs['collection'] }) filters['collection_version'] = get( latest_released_version, 'version') if is_collection_specified: owner_type = filters.pop('ownerType', None) owner = filters.pop('owner', None) if owner_type == USER_OBJECT_TYPE: filters['collection_owner_url'] = "/users/{}/".format( owner) if owner_type == ORG_OBJECT_TYPE: filters['collection_owner_url'] = "/orgs/{}/".format(owner) if not is_version_specified: filters['collection_version'] = HEAD if is_source_specified and not is_version_specified: filters['source_version'] = HEAD return filters
def test_persist_new_positive(self): kwargs = {'parent_resource': self.user} errors = Source.persist_new(self.new_source, self.user, **kwargs) source = Source.objects.get(name=self.new_source.name) self.assertEqual(len(errors), 0) self.assertTrue( Source.objects.filter(name=self.new_source.name).exists()) self.assertEqual(source.num_versions, 1) self.assertEqual(source.get_latest_version(), source) self.assertEqual(source.version, 'HEAD') self.assertFalse(source.released) self.assertEqual( source.uri, '/users/{username}/sources/{source}/'.format( username=self.user.username, source=source.mnemonic))
def prepare_object(self, validated_data, instance=None): source = instance if instance else Source() source.version = validated_data.get('version', source.version) or HEAD source.mnemonic = validated_data.get(self.Meta.lookup_field, source.mnemonic) source.name = validated_data.get('name', source.name) source.full_name = validated_data.get('full_name', source.full_name) source.description = validated_data.get('description', source.description) source.source_type = validated_data.get('source_type', source.source_type) source.custom_validation_schema = validated_data.get( 'custom_validation_schema', source.custom_validation_schema) source.public_access = validated_data.get( 'public_access', source.public_access or DEFAULT_ACCESS_TYPE) source.default_locale = validated_data.get( 'default_locale', source.default_locale or DEFAULT_LOCALE) source.website = validated_data.get('website', source.website) supported_locales = validated_data.get('supported_locales') if not supported_locales: supported_locales = source.supported_locales if supported_locales and isinstance(supported_locales, str): supported_locales = supported_locales.split( ',') # pragma: no cover source.supported_locales = supported_locales source.extras = validated_data.get('extras', source.extras) source.external_id = validated_data.get('external_id', source.external_id) source.user_id = validated_data.get('user_id', source.user_id) source.organization_id = validated_data.get('organization_id', source.organization_id) source.user = validated_data.get('user', source.user) source.organization = validated_data.get('organization', source.organization) source.released = validated_data.get('released', source.released) return source
def set_parent_resource(self, __pop=True): from core.sources.models import Source source = self.kwargs.pop('source', None) if __pop else self.kwargs.get( 'source', None) collection = self.kwargs.pop('collection', None) if __pop else self.kwargs.get( 'collection', None) container_version = self.kwargs.pop( 'version', HEAD) if __pop else self.kwargs.get('version', HEAD) parent_resource = None if 'org' in self.kwargs: filters = dict(organization__mnemonic=self.kwargs['org']) else: username = self.request.user.username if self.user_is_self else self.kwargs.get( 'user') filters = dict(user__username=username) if source: parent_resource = Source.get_version(source, container_version or HEAD, filters) if collection: from core.collections.models import Collection parent_resource = Collection.get_version(source, container_version or HEAD, filters) self.kwargs['parent_resource'] = self.parent_resource = parent_resource
def test_source_version_create_negative__same_version(self): source = OrganizationSourceFactory() self.assertEqual(source.num_versions, 1) OrganizationSourceFactory(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 process(self): source = Source(**self.data) errors = Source.persist_new_version(source, self.user) return errors or UPDATED
def process(self): source = Source(**self.data) errors = Source.persist_new(source, self.user) return errors or CREATED