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_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_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_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 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 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_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_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 _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_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 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 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 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 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_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 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 create_concept():
concept = Concept(name='namestring', uri='uristring', type='E21 Person')
concept.save()
return concept
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')
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_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_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])
