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
