def test_persist_new_positive(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.concepts))
kwargs = {
'parent_resource': self.source1,
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(self.name.name, concept.display_name)
self.assertEquals(self.name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(self.source1.public_access, concept.public_access)
self.assertEquals(1, concept.num_versions)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertEquals(concept_version, concept_version.root_version)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.concepts))
self.assertTrue(concept_version.id in source_version.concepts)
self.assertEquals(concept_version.mnemonic, concept_version.id)
def create_concept(user, source, names=None, mnemonic=None, descriptions=None, concept_class=None, datatype=None, force=False):
suffix = generate_random_string()
if not names and not force:
names = [create_localized_text("name{0}".format(suffix))]
if not mnemonic and not force:
mnemonic = 'concept{0}'.format(suffix)
if not descriptions and not force:
descriptions = [create_localized_text("desc{0}".format(suffix))]
concept = Concept(
mnemonic=mnemonic,
updated_by=user,
datatype=datatype if datatype else "None",
concept_class = concept_class if concept_class else 'Diagnosis',
names=names,
descriptions=descriptions,
)
if source is not None:
kwargs = {
'parent_resource': source,
}
errors = Concept.persist_new(concept, user, **kwargs)
else:
errors = Concept.persist_new(concept, user)
return concept, errors
def test_get_latest_version(self):
source = Source(name='source',
mnemonic='source',
full_name='Source One',
source_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.source1.com',
description='This is the first test source')
kwargs = {'parent_resource': self.org1}
Source.persist_new(source, self.user1, **kwargs)
concept1 = Concept(
mnemonic='concept12',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(concept1, self.user1, **kwargs)
concept = Concept.objects.get(mnemonic=concept1.mnemonic)
concept_version1 = ConceptVersion.objects.get(
versioned_object_id=concept.id)
self.assertEquals(concept.get_latest_version.id, concept_version1.id)
def create_concept(user,
source,
names=None,
mnemonic=None,
descriptions=None,
concept_class=None):
suffix = generate_random_string()
if not names:
names = [create_localized_text("name{0}".format(suffix))]
if not mnemonic:
mnemonic = 'concept{0}'.format(suffix)
if not descriptions:
descriptions = [create_localized_text("desc{0}".format(suffix))]
concept = Concept(
mnemonic=mnemonic,
updated_by=user,
datatype="None",
concept_class=concept_class if concept_class else 'First',
names=names,
descriptions=descriptions,
)
if source is not None:
kwargs = {
'parent_resource': source,
}
errors = Concept.persist_new(concept, user, **kwargs)
else:
errors = Concept.persist_new(concept, user)
return (concept, errors)
def test_concept_display_name_preferred(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
)
display_name1 = LocalizedText(
name='concept1',
locale='en',
locale_preferred=True
)
concept.names.append(display_name1)
display_name2 = LocalizedText(
name='le concept1',
locale='fr'
)
concept.names.append(display_name2)
concept.full_clean()
concept.save()
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(display_name1.name, concept.display_name)
self.assertEquals(display_name1.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(0, concept.num_versions)
def setUp(self):
super(ConceptVersionTest, self).setUp()
self.concept1 = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
external_id='EXTID',
names=[self.name],
)
display_name = LocalizedText(
name='concept1',
locale='en'
)
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
self.concept2 = Concept(
mnemonic='concept2',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Second',
names=[self.name],
)
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
def setUp(self):
super(ConceptVersionStaticMethodsTest, self).setUp()
self.concept1 = Concept(
mnemonic='concept1', concept_class='First', public_access=ACCESS_TYPE_EDIT)
display_name = LocalizedText(name='concept1', locale='en')
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
initial_version = ConceptVersion.get_latest_version_of(self.concept1)
self.concept2 = Concept(mnemonic='concept2', concept_class='Second', names=[self.name])
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
self.concept_version = ConceptVersion(
mnemonic='version1',
versioned_object=self.concept1,
concept_class='First',
names=self.concept1.names,
previous_version=initial_version,
created_by=self.user1.username,
updated_by=self.user1.username,
version_created_by=self.user1.username,
)
self.concept_version.full_clean()
self.concept_version.save()
def test_import_job_for_change_in_data(self):
stdout_stub = TestStream()
concept = Concept(
mnemonic='1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Diagnosis',
external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
names=[self.name])
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(concept, self.user1, **kwargs)
importer = ConceptsImporter(self.source1, self.testfile, 'test', stdout_stub, TestStream())
importer.import_concepts(total=1)
all_concept_versions = ConceptVersion.objects.all()
self.assertEquals(len(all_concept_versions), 2)
latest_concept_version = [version for version in all_concept_versions if version.previous_version][0]
self.assertEquals(len(latest_concept_version.names), 4)
self.assertTrue((
'Updated concept, replacing version ID ' + latest_concept_version.previous_version.id) in stdout_stub.getvalue())
self.assertTrue('concepts of 1 1 - 1 updated' in stdout_stub.getvalue())
def test_import_job_for_change_in_data(self):
stdout_stub = TestStream()
concept = Concept(mnemonic='1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Diagnosis',
external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
names=[self.name])
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(concept, self.user1, **kwargs)
importer = ConceptsImporter(self.source1, self.testfile, 'test',
stdout_stub, TestStream())
importer.import_concepts(total=1)
all_concept_versions = ConceptVersion.objects.all()
self.assertEquals(len(all_concept_versions), 2)
latest_concept_version = [
version for version in all_concept_versions
if version.previous_version
][0]
self.assertEquals(len(latest_concept_version.names), 4)
self.assertTrue(('Updated concept, replacing version ID ' +
latest_concept_version.previous_version.id
) in stdout_stub.getvalue())
self.assertTrue(
'concepts of 1 1 - 1 updated' in stdout_stub.getvalue())
def test_retire_positive(self):
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.concepts))
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(1, concept.num_versions)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertTrue(concept_version.is_latest_version)
self.assertFalse(concept_version.retired)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(concept_version.id, source_version.concepts[0])
errors = Concept.retire(concept, self.user1)
self.assertFalse(errors)
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertTrue(concept.retired)
self.assertEquals(2, concept.num_versions)
previous_version = ConceptVersion.objects.get(id=concept_version.id)
self.assertFalse(previous_version.is_latest_version)
self.assertFalse(previous_version.retired)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertTrue(concept_version.is_latest_version)
self.assertTrue(concept_version.retired)
self.assertEquals(self.user1.username,
concept_version.version_created_by)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(concept_version.id, source_version.concepts[0])
self.assertEquals(
1,
ConceptVersion.objects.filter(versioned_object_id=concept.id,
retired=True).count())
self.assertEquals(
1,
ConceptVersion.objects.filter(versioned_object_id=concept.id,
retired=False).count())
errors = Concept.retire(concept, self.user1)
self.assertEquals(1, len(errors))
def test_create_concept_negative__no_class(self):
with self.assertRaises(ValidationError):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
names=[self.name],
)
concept.full_clean()
concept.save()
def test_retire_positive(self):
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.concepts))
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(1, concept.num_versions)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertTrue(concept_version.is_latest_version)
self.assertFalse(concept_version.retired)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(concept_version.id, source_version.concepts[0])
errors = Concept.retire(concept, self.user1)
self.assertFalse(errors)
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertTrue(concept.retired)
self.assertEquals(2, concept.num_versions)
previous_version = ConceptVersion.objects.get(id=concept_version.id)
self.assertFalse(previous_version.is_latest_version)
self.assertFalse(previous_version.retired)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertTrue(concept_version.is_latest_version)
self.assertTrue(concept_version.retired)
self.assertEquals(self.user1.username, concept_version.version_created_by)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(concept_version.id, source_version.concepts[0])
self.assertEquals(
1, ConceptVersion.objects.filter(versioned_object_id=concept.id, retired=True).count())
self.assertEquals(
1, ConceptVersion.objects.filter(versioned_object_id=concept.id, retired=False).count())
errors = Concept.retire(concept, self.user1)
self.assertEquals(1, len(errors))
def test_resolve(self):
c = Concept(uri="http://www.digitalhps.org/concepts/CONe5b55803-1ef6-4abe-b81c-1493e97421df",
authority="ConceptpowerAuthority")
c.save()
resolve(Concept, c)
resolve(Type, c.typed)
self.assertTrue(hasattr(c, 'typed'))
self.assertFalse(c.typed is None)
self.assertTrue(c.resolved)
self.assertTrue(c.typed.resolved)
self.assertEqual(c.pos, 'noun')
def test_resolve(self):
c = Concept(uri="http://www.digitalhps.org/concepts/CONe5b55803-1ef6-4abe-b81c-1493e97421df",
authority="ConceptpowerAuthority")
c.save()
resolve(Concept, c)
resolve(Type, c.typed)
self.assertTrue(hasattr(c, 'typed'))
self.assertFalse(c.typed is None)
self.assertTrue(c.resolved)
self.assertTrue(c.typed.resolved)
self.assertEqual(c.pos, 'noun')
def test_persist_new_negative__repeated_mnemonic(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.concepts))
kwargs = {
'parent_resource': self.source1,
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(self.name.name, concept.display_name)
self.assertEquals(self.name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(self.source1.public_access, concept.public_access)
self.assertEquals(1, concept.num_versions)
concept_version = ConceptVersion.get_latest_version_of(concept)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.concepts))
self.assertTrue(concept_version.id in source_version.concepts)
# Repeat with same mnemonic
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(1, len(errors))
self.assertTrue('__all__' in errors)
self.assertEquals(0, concept.num_versions)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(1, len(source_version.concepts))
def test_dispatch_with_head_and_versions(self):
source_version = SourceVersion(
name='version1',
mnemonic='version1',
versioned_object=self.source1,
released=True,
created_by=self.user1,
updated_by=self.user1,
)
source_version.full_clean()
source_version.save()
concept2 = Concept(
mnemonic='concept2',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='not First',
external_id='EXTID',
names=[self.name],
)
display_name = LocalizedText(
name='concept2',
locale='en'
)
concept2.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(concept2, self.user1, **kwargs)
self.client.login(username='******', password='******')
kwargs = {
'org': self.org1.mnemonic,
'source': self.source1.mnemonic
}
response = self.client.get(reverse('concept-create', kwargs=kwargs))
self.assertEquals(response.status_code, 200)
content = json.loads(response.content)
self.assertEquals(2, len(content))
source_head_concepts = SourceVersion.objects.get(mnemonic='HEAD', versioned_object_id=self.source1.id).concepts
self.assertEquals(2, len(source_head_concepts))
for concept in content:
self.assertTrue(concept['version'] in source_head_concepts)
def setUp(self):
super(ConceptVersionStaticMethodsTest, self).setUp()
self.concept1 = Concept(mnemonic='concept1',
concept_class='First',
public_access=ACCESS_TYPE_EDIT)
display_name = LocalizedText(name='concept1', locale='en')
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
initial_version = ConceptVersion.get_latest_version_of(self.concept1)
self.concept2 = Concept(mnemonic='concept2',
concept_class='Second',
names=[self.name])
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
self.concept_version = ConceptVersion(
mnemonic='version1',
versioned_object=self.concept1,
concept_class='First',
names=self.concept1.names,
previous_version=initial_version,
created_by=self.user1.username,
updated_by=self.user1.username,
version_created_by=self.user1.username,
)
self.concept_version.full_clean()
self.concept_version.save()
def test_create_concept_positive(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
concept.full_clean()
concept.save()
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(self.name.name, concept.display_name)
self.assertEquals(self.name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(0, concept.num_versions)
def create_concept(user,
source,
source_version=None,
names=None,
mnemonic=None,
descriptions=None,
concept_class=None,
datatype=None,
force=False,
extras=None):
suffix = generate_random_string()
if not names and not force:
names = [create_localized_text("name{0}".format(suffix))]
if not mnemonic and not force:
mnemonic = 'concept{0}'.format(suffix)
if not descriptions and not force:
descriptions = [create_localized_text("desc{0}".format(suffix))]
concept = Concept(
mnemonic=mnemonic,
updated_by=user,
datatype=datatype if datatype else "None",
concept_class=concept_class if concept_class else 'Diagnosis',
names=names,
descriptions=descriptions,
extras=extras)
if source is not None:
kwargs = {
'parent_resource': source,
}
if source_version is not None:
kwargs['parent_resource_version'] = source_version
errors = Concept.persist_new(concept, user, **kwargs)
else:
errors = Concept.persist_new(concept, user)
return concept, errors
def destroy(self, request, *args, **kwargs):
self.permission_classes = (CanEditParentDictionary, )
concept = self.get_object_or_none()
if concept is None:
return Response(
{'non_field_errors': 'Could not find concept to retire'},
status=status.HTTP_404_NOT_FOUND)
errors = Concept.retire(concept, request.user)
if errors:
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
def test_persist_new_negative__no_parent(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.concepts))
errors = Concept.persist_new(concept, self.user1)
self.assertEquals(1, len(errors))
self.assertTrue('parent' in errors)
self.assertFalse(Concept.objects.filter(mnemonic='concept1').exists())
self.assertEquals(0, concept.num_versions)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(0, len(source_version.concepts))
def test_update_concept_with_invalid_record(self):
concept = Concept(
mnemonic='1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Diagnosis',
external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
names=[self.name])
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(concept, self.user1, **kwargs)
self.testfile = open('./integration_tests/fixtures/concept_without_fully_specified_name.json', 'rb')
stderr_stub = TestStream()
importer = ConceptsImporter(self.source1, self.testfile, 'test', TestStream(), stderr_stub)
importer.import_concepts(total=1)
self.assertTrue('Concept requires at least one fully specified name' in stderr_stub.getvalue())
self.assertEquals(1, Concept.objects.count())
self.assertEquals(1, ConceptVersion.objects.count())
def destroy(self, request, *args, **kwargs):
self.permission_classes = (CanEditParentDictionary,)
concept = self.get_object_or_none()
if concept is None:
return Response(
{'non_field_errors': 'Could not find concept to retire'},
status=status.HTTP_404_NOT_FOUND)
errors = Concept.retire(concept, request.user)
if errors:
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_204_NO_CONTENT)
def test_persist_new_positive__earlier_source_version(self):
version1 = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(version1.concepts))
version2 = SourceVersion.for_base_object(self.source1,
label='version2')
version2.save()
self.assertEquals(0, len(version2.concepts))
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
'parent_resource_version': version1
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(self.name.name, concept.display_name)
self.assertEquals(self.name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(self.source1.public_access, concept.public_access)
self.assertEquals(1, concept.num_versions)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertEquals(concept_version, concept_version.root_version)
version1 = SourceVersion.objects.get(id=version1.id)
self.assertEquals(1, len(version1.concepts))
self.assertTrue(concept_version.id in version1.concepts)
version2 = SourceVersion.objects.get(id=version2.id)
self.assertEquals(0, len(version2.concepts))
self.assertFalse(concept_version.id in version2.concepts)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.data["cs_name"] = self.data["variable_name"]
self.data["name"] = self.data["variable_name"].lower()
self.data["dataset"] = Dataset.get_or_create(
dict(name=self.data["dataset_name"].lower(),
study=self.data["study_object"])).pk
if self.data.get("concept_name", "") == "":
self.data["concept"] = None
else:
self.data["concept"] = Concept.get_or_create(
dict(name=self.data["concept_name"].lower())).pk
def test_concept_access_changes_with_source(self):
public_access = self.source1.public_access
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
public_access=public_access,
concept_class='First',
names=[self.name],
)
concept.full_clean()
concept.save()
self.assertEquals(self.source1.public_access, concept.public_access)
self.source1.public_access = ACCESS_TYPE_VIEW
self.source1.save()
concept = Concept.objects.get(id=concept.id)
self.assertNotEquals(public_access, self.source1.public_access)
self.assertEquals(self.source1.public_access, concept.public_access)
def update_concept_retired_status(self, concept, new_retired_state):
""" Updates and persists a new retired status for a concept """
# Do nothing if retired status is unchanged
concept_version = ConceptVersion.get_latest_version_of(concept)
if concept_version.retired == new_retired_state:
return ImportActionHelper.IMPORT_ACTION_NONE
# Retire/un-retire the concept
if new_retired_state:
if not self.test_mode:
errors = Concept.retire(concept, self.user)
if errors:
raise IllegalInputException('Failed to retire concept due to %s' % errors)
return ImportActionHelper.IMPORT_ACTION_RETIRE
else:
if not self.test_mode:
errors = Concept.unretire(concept, self.user)
if errors:
raise IllegalInputException('Failed to un-retire concept due to %s' % errors)
return ImportActionHelper.IMPORT_ACTION_UNRETIRE
def setUp(self):
super(ConceptVersionTest, self).setUp()
self.concept1 = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
external_id='EXTID',
names=[self.name],
)
display_name = LocalizedText(name='concept1', locale='en')
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
self.concept2 = Concept(
mnemonic='concept2',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Second',
names=[self.name],
)
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
def test_concept_display_name(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
display_name = LocalizedText(
name='concept1',
locale='en',
locale_preferred=True,
)
concept.names.append(display_name)
concept.full_clean()
concept.save()
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(display_name.name, concept.display_name)
self.assertEquals(display_name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(0, concept.num_versions)
def add_concept(request):
new_con = Concept()
new_con.title = request.POST['title']
new_con.description = request.POST['description']
new_con.pub_date = datetime.datetime.now()
new_con.date_modified = new_con.pub_date
new_con.id = bson.ObjectId()
new_con.author = request.user
cat_assoc = CategoryAssociation()
cat = Category.objects.get(id=request.POST['category_id'])
cat_assoc.category = cat
new_con.categories.append(cat_assoc)
form_properties = get_new_properties(request, True)
for form_property in form_properties:
#ugly upsert (in case its not in db)
Feature.objects(
title=form_property.title,
is_property=True,
property_type=form_property.property_type
).update_one(
set__title=form_property.title,
set__is_property=True,
set__property_type=form_property.property_type,
upsert=True)
new_feature = Feature.objects.filter(
title=form_property.title,
is_property=True,
property_type=form_property.property_type
)[0]
new_property = Property(
feature=new_feature,
property_id=bson.ObjectId(),
value=form_property.value)
new_con.properties.append(new_property)
new_con.save()
return HttpResponseRedirect(reverse('concepts:conceptdetail', args=(new_con.id,)))
def _remote_concept(uri, authority):
"""
Retrieve a Concept from a remote authority service.
"""
logging.debug("Retrieve remote concept for {0}.".format(uri))
querystring = authority.retrieveformat.format(uri) # "/Concept?id="+uri
response = urllib2.urlopen(authority.host + querystring).read()
root = ET.fromstring(response)
data = {}
if len(root) > 0:
for node in root:
if node.tag == '{' + authority.namespace + '/}conceptEntry':
for sn in node:
dkey = sn.tag.replace('{' + authority.namespace + '/}', '')
data[dkey] = sn.text
if sn.tag == '{' + authority.namespace + '/}type':
data['type_id'] = sn.get('type_id')
data['type_uri'] = sn.get('type_uri')
if data == {}: # Nothing retrieved
logging.warning("No such concept in ConceptAuthority for " +\
" namespace {0}".format(authority.namespace))
raise ValueError("No such concept in ConceptAuthority for " +\
" namespace {0}".format(authority.namespace))
# Get Concept type.
ctype = ConceptType.objects.get_unique(data['type'], data['type_uri'])
concept = Concept(uri=uri,
name=data['lemma'],
type=ctype,
equalto=data['equal_to'],
similarto=data['similar_to'])
concept.save()
logging.debug("Concept saved.")
# Check for geonames URI in similar_to field, and get the corresponding
# Location.
if data['similar_to'] is not None:
logging.debug("similar_to field is not empty.")
try:
location = retrieve_location(data['similar_to'])
except RuntimeError:
location = None
if location is not None:
logging.debug("Found a Location based on similar_to field")
concept.location_id = location.id
concept.save()
else:
logging.debug("No Location found.")
return concept
def setUp(self):
self.skipTest('Collections and concept references not yet supported.')
super(ConceptReferenceBaseTest, self).setUp()
self.concept1 = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
display_name = LocalizedText(
name='concept1',
locale='en'
)
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
self.version1 = ConceptVersion.for_concept(self.concept1, 'version1')
self.version1.save()
self.concept2 = Concept(
mnemonic='concept2',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Second',
names=[self.name],
)
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
self.version2 = ConceptVersion.for_concept(self.concept2, 'version2')
self.version2.save()
def test_update_concept_with_invalid_record(self):
concept = Concept(mnemonic='1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='Diagnosis',
external_id='1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
names=[self.name])
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(concept, self.user1, **kwargs)
self.testfile = open(
'./integration_tests/fixtures/concept_without_fully_specified_name.json',
'rb')
stderr_stub = TestStream()
importer = ConceptsImporter(self.source1, self.testfile, 'test',
TestStream(), stderr_stub)
importer.import_concepts(total=1)
self.assertTrue('Concept requires at least one fully specified name' in
stderr_stub.getvalue())
self.assertEquals(1, Concept.objects.count())
self.assertEquals(1, ConceptVersion.objects.count())
def update_concept_retired_status(self, concept, new_retired_state):
""" Updates and persists a new retired status for a concept """
# Do nothing if retired status is unchanged
concept_version = ConceptVersion.get_latest_version_of(concept)
if concept_version.retired == new_retired_state:
return ImportActionHelper.IMPORT_ACTION_NONE
# Retire/un-retire the concept
if new_retired_state:
if not self.test_mode:
errors = Concept.retire(concept, self.user)
if errors:
raise IllegalInputException(
'Failed to retire concept due to %s' % errors)
return ImportActionHelper.IMPORT_ACTION_RETIRE
else:
if not self.test_mode:
errors = Concept.unretire(concept, self.user)
if errors:
raise IllegalInputException(
'Failed to un-retire concept due to %s' % errors)
return ImportActionHelper.IMPORT_ACTION_UNRETIRE
def test_create_concept_negative__no_mnemonic(self):
with self.assertRaises(ValidationError):
concept = Concept(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
concept.full_clean()
concept.save()
def restore_object(self, attrs, instance=None):
concept = instance if instance else Concept()
concept.mnemonic = attrs.get(self.Meta.lookup_field, concept.mnemonic)
concept.external_id = attrs.get('external_id', concept.external_id)
concept.concept_class = attrs.get('concept_class', concept.concept_class)
concept.datatype = attrs.get('datatype', concept.datatype)
concept.extras = attrs.get('extras', concept.extras)
concept.retired = attrs.get('retired', concept.retired)
# Is this desired behavior??
concept.names = attrs.get('names', concept.names)
# Is this desired behavior??
concept.descriptions = attrs.get('descriptions', concept.descriptions)
concept.extras = attrs.get('extras', concept.extras)
return concept
def _remote_concept(uri, authority):
"""
Retrieve a Concept from a remote authority service.
"""
logging.debug("Retrieve remote concept for {0}.".format(uri))
querystring = authority.retrieveformat.format(uri) # "/Concept?id="+uri
response = urllib2.urlopen(authority.host+querystring).read()
root = ET.fromstring(response)
data = {}
if len(root) > 0:
for node in root:
if node.tag == '{'+authority.namespace+'/}conceptEntry':
for sn in node:
dkey = sn.tag.replace('{'+authority.namespace+'/}','')
data[dkey] = sn.text
if sn.tag == '{'+authority.namespace+'/}type':
data['type_id'] = sn.get('type_id')
data['type_uri'] = sn.get('type_uri')
if data == {}: # Nothing retrieved
logging.warning("No such concept in ConceptAuthority for " +\
" namespace {0}".format(authority.namespace))
raise ValueError("No such concept in ConceptAuthority for " +\
" namespace {0}".format(authority.namespace))
# Get Concept type.
ctype = ConceptType.objects.get_unique(data['type'], data['type_uri'])
concept = Concept(uri=uri,
name=data['lemma'],
type=ctype,
equalto=data['equal_to'],
similarto=data['similar_to'])
concept.save()
logging.debug("Concept saved.")
# Check for geonames URI in similar_to field, and get the corresponding
# Location.
if data['similar_to'] is not None:
logging.debug("similar_to field is not empty.")
try:
location = retrieve_location(data['similar_to'])
except RuntimeError:
location = None
if location is not None:
logging.debug("Found a Location based on similar_to field")
concept.location_id = location.id
concept.save()
else:
logging.debug("No Location found.")
return concept
def test_persist_new_negative__no_parent(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
source_version = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(source_version.concepts))
errors = Concept.persist_new(concept, self.user1)
self.assertEquals(1, len(errors))
self.assertTrue('parent' in errors)
self.assertFalse(Concept.objects.filter(mnemonic='concept1').exists())
self.assertEquals(0, concept.num_versions)
source_version = SourceVersion.objects.get(id=source_version.id)
self.assertEquals(0, len(source_version.concepts))
def test_persist_new_positive__earlier_source_version(self):
version1 = SourceVersion.get_latest_version_of(self.source1)
self.assertEquals(0, len(version1.concepts))
version2 = SourceVersion.for_base_object(self.source1, label='version2')
version2.save()
self.assertEquals(0, len(version2.concepts))
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
'parent_resource_version': version1
}
errors = Concept.persist_new(concept, self.user1, **kwargs)
self.assertEquals(0, len(errors))
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(self.name.name, concept.display_name)
self.assertEquals(self.name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(self.source1.public_access, concept.public_access)
self.assertEquals(1, concept.num_versions)
concept_version = ConceptVersion.get_latest_version_of(concept)
self.assertEquals(concept_version, concept_version.root_version)
version1 = SourceVersion.objects.get(id=version1.id)
self.assertEquals(1, len(version1.concepts))
self.assertTrue(concept_version.id in version1.concepts)
version2 = SourceVersion.objects.get(id=version2.id)
self.assertEquals(0, len(version2.concepts))
self.assertFalse(concept_version.id in version2.concepts)
def restore_object(self, attrs, instance=None):
print 'ConceptDetailSerializer attrs: ', attrs
concept = instance if instance else Concept()
concept.mnemonic = attrs.get(self.Meta.lookup_field, concept.mnemonic)
concept.external_id = attrs.get('external_id', concept.external_id)
concept.concept_class = attrs.get('concept_class',
concept.concept_class)
concept.datatype = attrs.get('datatype', concept.datatype)
concept.extras = attrs.get('extras', concept.extras)
concept.retired = attrs.get('retired', concept.retired)
concept.forked_from_url = attrs.get('forked_from_url',
concept.forked_from_url)
concept.forked_concept_version = attrs.get('version', concept.version)
# Is this desired behavior??
concept.names = attrs.get('names', concept.names)
# Is this desired behavior??
concept.descriptions = attrs.get('descriptions', concept.descriptions)
concept.extras = attrs.get('extras', concept.extras)
return concept
def test_create_concept_positive(self):
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
concept.full_clean()
concept.save()
self.assertTrue(Concept.objects.filter(mnemonic='concept1').exists())
self.assertFalse(concept.retired)
self.assertEquals(self.name.name, concept.display_name)
self.assertEquals(self.name.locale, concept.display_locale)
self.assertEquals(self.source1.owner_name, concept.owner_name)
self.assertEquals(self.source1.owner_type, concept.owner_type)
self.assertEquals(0, concept.num_versions)
def test_concept_access_changes_with_source(self):
public_access = self.source1.public_access
concept = Concept(
mnemonic='concept1',
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
public_access=public_access,
concept_class='First',
names=[self.name],
)
concept.full_clean()
concept.save()
self.assertEquals(self.source1.public_access, concept.public_access)
self.source1.public_access = ACCESS_TYPE_VIEW
self.source1.save()
concept = Concept.objects.get(id=concept.id)
self.assertNotEquals(public_access, self.source1.public_access)
self.assertEquals(self.source1.public_access, concept.public_access)
def test_get_method_failure(self, db):
dictionary = dict(name="some-name")
# TODO: Workaround with actual model. Remove this dependency
object = Concept.get(dictionary)
assert object is None
def create_concept():
concept = Concept(name='namestring', uri='uristring', type='E21 Person')
concept.save()
return concept
def save_object(self, obj, **kwargs):
request_user = self.context['request'].user
errors = Concept.persist_new(obj, request_user, **kwargs)
self._errors.update(errors)
def test_collections_version_ids(self):
kwargs = {'parent_resource': self.userprofile1}
collection = Collection(
name='collection2',
mnemonic='collection2',
full_name='Collection Two',
collection_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.collection2.com',
description='This is the second test collection')
Collection.persist_new(collection, self.user1, **kwargs)
source = Source(name='source',
mnemonic='source',
full_name='Source One',
source_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.source1.com',
description='This is the first test source')
kwargs = {'parent_resource': self.org1}
Source.persist_new(source, self.user1, **kwargs)
concept1 = Concept(
mnemonic='concept12',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(concept1, self.user1, **kwargs)
fromConcept = Concept(
mnemonic='fromConcept',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(fromConcept, self.user1, **kwargs)
toConcept = Concept(
mnemonic='toConcept',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(toConcept, self.user1, **kwargs)
mapping = Mapping(
map_type='Same As',
from_concept=fromConcept,
to_concept=toConcept,
external_id='mapping',
)
kwargs = {
'parent_resource': source,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
from_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
mnemonic=fromConcept.mnemonic).mnemonic + '/'
concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
mnemonic=concept1.mnemonic).mnemonic + '/'
mapping = Mapping.objects.filter()[1]
mapping_reference = '/orgs/org1/sources/source/mappings/' + mapping.id + '/'
references = [
concept1_reference, from_concept_reference, mapping_reference
]
collection.expressions = references
collection.full_clean()
collection.save()
self.assertEquals(mapping.collection_version_ids, [
Collection.objects.get(mnemonic=collection.mnemonic).get_head().id
])
def test_index_all_method_with_one_concept(self, mocker, concept):
mocker.patch("concepts.models.Concept.index")
Concept.index_all()
Concept.index.assert_called_once()
class ConceptVersionStaticMethodsTest(ConceptBaseTest):
def setUp(self):
super(ConceptVersionStaticMethodsTest, self).setUp()
self.concept1 = Concept(mnemonic='concept1',
concept_class='First',
public_access=ACCESS_TYPE_EDIT)
display_name = LocalizedText(name='concept1', locale='en')
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
initial_version = ConceptVersion.get_latest_version_of(self.concept1)
self.concept2 = Concept(mnemonic='concept2',
concept_class='Second',
names=[self.name])
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
self.concept_version = ConceptVersion(
mnemonic='version1',
versioned_object=self.concept1,
concept_class='First',
names=self.concept1.names,
previous_version=initial_version,
created_by=self.user1.username,
updated_by=self.user1.username,
version_created_by=self.user1.username,
)
self.concept_version.full_clean()
self.concept_version.save()
def test_for_concept_positive(self):
self.concept1.datatype = 'Boolean'
self.concept1.save()
label = 'version1'
version = ConceptVersion.for_concept(self.concept1, label)
self.assertEquals(label, version.mnemonic)
self.assertEquals(self.concept1, version.versioned_object)
self.assertEquals(self.concept1.concept_class, version.concept_class)
self.assertEquals(self.concept1.datatype, version.datatype)
self.assertEquals(self.concept1.names, version.names)
self.assertEquals(self.concept1.descriptions, version.descriptions)
self.assertEquals(self.concept1.retired, version.retired)
self.assertEquals(self.concept1.public_access, version.public_access)
self.assertEquals(self.concept1.external_id, version.external_id)
self.assertFalse(version.released)
def test_persist_clone_positive(self):
self.assertEquals(2, self.concept1.num_versions)
self.assertEquals(self.concept_version,
ConceptVersion.get_latest_version_of(self.concept1))
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.update_concept_version(self.concept_version)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(self.concept_version.id, source_version.concepts[0])
version2 = self.concept_version.clone()
errors = ConceptVersion.persist_clone(version2, self.user1)
self.assertEquals(0, len(errors))
self.assertEquals(3, self.concept1.num_versions)
self.assertEquals(version2,
ConceptVersion.get_latest_version_of(self.concept1))
self.assertEquals(self.concept_version.public_access,
version2.public_access)
self.assertEquals(self.concept_version, version2.previous_version)
self.assertEquals(self.concept_version.root_version,
version2.root_version)
self.assertEquals(self.concept_version.external_id,
version2.external_id)
self.assertEquals(self.user1.username, version2.version_created_by)
source_version.update_concept_version(version2)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(version2.id, source_version.concepts[0])
def test_persist_clone_negative__no_user(self):
self.assertEquals(2, self.concept1.num_versions)
self.assertEquals(self.concept_version,
ConceptVersion.get_latest_version_of(self.concept1))
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.update_concept_version(self.concept_version)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(self.concept_version.id, source_version.concepts[0])
version2 = self.concept_version.clone()
errors = ConceptVersion.persist_clone(version2)
self.assertEquals(1, len(errors))
self.assertTrue('version_created_by' in errors)
self.assertEquals(2, self.concept1.num_versions)
self.assertEquals(self.concept_version,
ConceptVersion.get_latest_version_of(self.concept1))
def retrieve_concept(uri):
# Determine namespace and find matching ConceptAuthority.
o = urlparse(uri)
namespace = o.scheme + "://" + o.netloc
if o.scheme == '' or o.netloc == '':
logging.error("Could not determine namespace for concept {0}".format(uri))
raise ValueError("Could not determine namespace for concept {0}".format(uri))
try:
authority = ConceptAuthority.objects.filter(namespace=namespace).get()
except ObjectDoesNotExist:
logging.error("No ConceptAuthority for namespace {0}.".format(namespace))
raise RuntimeError("No ConceptAuthority for namespace {0}.".format(namespace))
# Check for existing concept before calling the authority.
try:
concept = Concept.objects.filter(uri=uri).get()
logging.debug("Concept already exists.")
except ObjectDoesNotExist:
logging.debug("Concept does not exist.")
querystring = authority.retrieveformat.format(uri) # "/Concept?id="+uri
response = urllib2.urlopen(authority.host+querystring).read()
root = ET.fromstring(response)
data = {}
if len(root) > 0:
for node in root:
if node.tag == '{'+authority.namespace+'/}conceptEntry':
for sn in node:
dkey = sn.tag.replace('{'+authority.namespace+'/}','')
data[dkey] = sn.text
if sn.tag == '{'+authority.namespace+'/}type':
data['type_id'] = sn.get('type_id')
data['type_uri'] = sn.get('type_uri')
if data == {}: # Nothing retrieved
logging.warning("No such concept in ConceptAuthority for " +\
" namespace {0}".format(authority.namespace))
raise ValueError("No such concept in ConceptAuthority for " +\
" namespace {0}".format(authority.namespace))
concept = Concept(uri=uri,
name=data['lemma'],
type=data['type'],
equalto=data['equal_to'],
similarto=data['similar_to'])
concept.save()
logging.debug("Concept saved.")
# Check for geonames URI in similar_to field, and get the corresponding
# Location.
if data['similar_to'] is not None:
logging.debug("similar_to field is not empty.")
location = retrieve_location(data['similar_to'])
if location is not None:
logging.debug("Found a Location based on similar_to field")
concept.location_id = location.id
else:
logging.debug("No Location found.")
return concept
class ConceptVersionStaticMethodsTest(ConceptBaseTest):
def setUp(self):
super(ConceptVersionStaticMethodsTest, self).setUp()
self.concept1 = Concept(
mnemonic='concept1', concept_class='First', public_access=ACCESS_TYPE_EDIT)
display_name = LocalizedText(name='concept1', locale='en')
self.concept1.names.append(display_name)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
initial_version = ConceptVersion.get_latest_version_of(self.concept1)
self.concept2 = Concept(mnemonic='concept2', concept_class='Second', names=[self.name])
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
self.concept_version = ConceptVersion(
mnemonic='version1',
versioned_object=self.concept1,
concept_class='First',
names=self.concept1.names,
previous_version=initial_version,
created_by=self.user1.username,
updated_by=self.user1.username,
version_created_by=self.user1.username,
)
self.concept_version.full_clean()
self.concept_version.save()
def test_for_concept_positive(self):
self.concept1.datatype = 'Boolean'
self.concept1.save()
label = 'version1'
version = ConceptVersion.for_concept(self.concept1, label)
self.assertEquals(label, version.mnemonic)
self.assertEquals(self.concept1, version.versioned_object)
self.assertEquals(self.concept1.concept_class, version.concept_class)
self.assertEquals(self.concept1.datatype, version.datatype)
self.assertEquals(self.concept1.names, version.names)
self.assertEquals(self.concept1.descriptions, version.descriptions)
self.assertEquals(self.concept1.retired, version.retired)
self.assertEquals(self.concept1.public_access, version.public_access)
self.assertEquals(self.concept1.external_id, version.external_id)
self.assertFalse(version.released)
def test_persist_clone_positive(self):
self.assertEquals(2, self.concept1.num_versions)
self.assertEquals(
self.concept_version, ConceptVersion.get_latest_version_of(self.concept1))
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.update_concept_version(self.concept_version)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(self.concept_version.id, source_version.concepts[0])
version2 = self.concept_version.clone()
errors = ConceptVersion.persist_clone(version2, self.user1)
self.assertEquals(0, len(errors))
self.assertEquals(3, self.concept1.num_versions)
self.assertEquals(version2, ConceptVersion.get_latest_version_of(self.concept1))
self.assertEquals(self.concept_version.public_access, version2.public_access)
self.assertEquals(self.concept_version, version2.previous_version)
self.assertEquals(self.concept_version.root_version, version2.root_version)
self.assertEquals(self.concept_version.external_id, version2.external_id)
self.assertEquals(self.user1.username, version2.version_created_by)
source_version.update_concept_version(version2)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(version2.id, source_version.concepts[0])
def test_persist_clone_negative__no_user(self):
self.assertEquals(2, self.concept1.num_versions)
self.assertEquals(
self.concept_version, ConceptVersion.get_latest_version_of(self.concept1))
source_version = SourceVersion.get_latest_version_of(self.source1)
source_version.update_concept_version(self.concept_version)
self.assertEquals(1, len(source_version.concepts))
self.assertEquals(self.concept_version.id, source_version.concepts[0])
version2 = self.concept_version.clone()
errors = ConceptVersion.persist_clone(version2)
self.assertEquals(1, len(errors))
self.assertTrue('version_created_by' in errors)
self.assertEquals(2, self.concept1.num_versions)
self.assertEquals(
self.concept_version, ConceptVersion.get_latest_version_of(self.concept1))
def setUp(self):
self.user1 = User.objects.create_user(
username='******',
email='*****@*****.**',
password='******',
last_name='One',
first_name='User'
)
self.user2 = User.objects.create_user(
username='******',
email='*****@*****.**',
password='******',
last_name='Two',
first_name='User'
)
self.userprofile1 = UserProfile.objects.create(user=self.user1, mnemonic='user1')
self.userprofile2 = UserProfile.objects.create(user=self.user2, mnemonic='user2')
self.org1 = Organization.objects.create(name='org1', mnemonic='org1')
self.org2 = Organization.objects.create(name='org2', mnemonic='org2')
add_user_to_org(self.userprofile2, self.org2)
self.source1 = Source(
name='source1',
mnemonic='source1',
full_name='Source One',
source_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.source1.com',
description='This is the first test source',
)
kwargs = {
'parent_resource': self.userprofile1
}
Source.persist_new(self.source1, self.user1, **kwargs)
self.source1 = Source.objects.get(id=self.source1.id)
self.source2 = Source(
name='source2',
mnemonic='source2',
full_name='Source Two',
source_type='Reference',
public_access=ACCESS_TYPE_VIEW,
default_locale='fr',
supported_locales=['fr'],
website='www.source2.com',
description='This is the second test source',
)
kwargs = {
'parent_resource': self.org2,
}
Source.persist_new(self.source2, self.user1, **kwargs)
self.source2 = Source.objects.get(id=self.source2.id)
self.name = LocalizedText.objects.create(name='Fred', locale='en', type='FULLY_SPECIFIED')
self.concept1 = Concept(
mnemonic='concept1',
updated_by=self.user1,
parent=self.source1,
concept_class='First',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept1, self.user1, **kwargs)
self.concept2 = Concept(
mnemonic='concept2',
updated_by=self.user1,
parent=self.source1,
concept_class='Second',
names=[self.name],
)
kwargs = {
'parent_resource': self.source1,
}
Concept.persist_new(self.concept2, self.user1, **kwargs)
self.concept3 = Concept(
mnemonic='concept3',
updated_by=self.user1,
parent=self.source2,
concept_class='Third',
names=[self.name],
)
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept3, self.user1, **kwargs)
self.concept4 = Concept(
mnemonic='concept4',
updated_by=self.user2,
parent=self.source2,
concept_class='Fourth',
names=[self.name],
)
kwargs = {
'parent_resource': self.source2,
}
Concept.persist_new(self.concept4, self.user1, **kwargs)
def test_index_all_method_with_no_concepts(self, db):
Concept.index_all()
def save_object(self, obj, **kwargs):
request_user = self.context['request'].user
errors = Concept.persist_new(obj, request_user, **kwargs)
self._errors.update(errors)
def test_collections_version_ids(self):
kwargs = {
'parent_resource': self.userprofile1
}
collection = Collection(
name='collection2',
mnemonic='collection2',
full_name='Collection Two',
collection_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.collection2.com',
description='This is the second test collection'
)
Collection.persist_new(collection, self.user1, **kwargs)
source = Source(
name='source',
mnemonic='source',
full_name='Source One',
source_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.source1.com',
description='This is the first test source'
)
kwargs = {
'parent_resource': self.org1
}
Source.persist_new(source, self.user1, **kwargs)
concept1 = Concept(
mnemonic='concept12',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es', type='FULLY_SPECIFIED')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(concept1, self.user1, **kwargs)
fromConcept = Concept(
mnemonic='fromConcept',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es', type='FULLY_SPECIFIED')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(fromConcept, self.user1, **kwargs)
toConcept = Concept(
mnemonic='toConcept',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es', type='FULLY_SPECIFIED')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(toConcept, self.user1, **kwargs)
mapping = Mapping(
map_type='Same As',
from_concept=fromConcept,
to_concept=toConcept,
external_id='mapping',
)
kwargs = {
'parent_resource': source,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
mapping = Mapping.objects.filter()[1]
mapping_reference = '/orgs/org1/sources/source/mappings/' + mapping.id + '/'
references = [mapping_reference]
collection.expressions = references
collection.full_clean()
collection.save()
mapping_version = MappingVersion.objects.filter()[0]
collection_version = CollectionVersion(
name='version1',
mnemonic='version1',
versioned_object=collection,
released=True,
created_by=self.user1,
updated_by=self.user1,
mappings=[mapping_version.id]
)
collection_version.full_clean()
collection_version.save()
self.assertEquals(mapping_version.collection_version_ids, [collection_version.id])
def test_collections_version_ids(self):
kwargs = {'parent_resource': self.userprofile1}
collection = Collection(
name='collection2',
mnemonic='collection2',
full_name='Collection Two',
collection_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.collection2.com',
description='This is the second test collection')
Collection.persist_new(collection, self.user1, **kwargs)
source = Source(name='source',
mnemonic='source',
full_name='Source One',
source_type='Dictionary',
public_access=ACCESS_TYPE_EDIT,
default_locale='en',
supported_locales=['en'],
website='www.source1.com',
description='This is the first test source')
kwargs = {'parent_resource': self.org1}
Source.persist_new(source, self.user1, **kwargs)
concept1 = Concept(
mnemonic='concept12',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(concept1, self.user1, **kwargs)
another_concept = Concept(
mnemonic='anotherConcept',
created_by=self.user1,
updated_by=self.user1,
parent=source,
concept_class='First',
names=[LocalizedText.objects.create(name='User', locale='es')],
)
kwargs = {
'parent_resource': source,
}
Concept.persist_new(another_concept, self.user1, **kwargs)
another_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
mnemonic=another_concept.mnemonic).mnemonic + '/'
concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
mnemonic=concept1.mnemonic).mnemonic + '/'
references = [concept1_reference, another_concept_reference]
collection.expressions = references
collection.full_clean()
collection.save()
concept_version = ConceptVersion.objects.get(
versioned_object_id=Concept.objects.get(
mnemonic=another_concept.mnemonic).id)
version = CollectionVersion.for_base_object(collection, 'version1')
kwargs = {}
CollectionVersion.persist_new(version, **kwargs)
self.assertEquals(
concept_version.collection_version_ids,
[CollectionVersion.objects.get(mnemonic='version1').id])
def create_concept():
concept = Concept( name = 'namestring',
uri = 'uristring',
type = 'E21 Person' )
concept.save()
return concept
