def test_create_mapping_positive(self):
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mappingversion1',
versioned_object_id=self.mapping1.id,
mnemonic='tempid',
versioned_object_type=ContentType.objects.get_for_model(Mapping),
)
mapping_version.full_clean()
mapping_version.save()
self.assertTrue(MappingVersion.objects.filter(versioned_object_id = self.mapping1.id).exists())
mapping_version = MappingVersion.objects.get(versioned_object_id = self.mapping1.id)
self.assertEquals(ACCESS_TYPE_VIEW, mapping_version.public_access)
self.assertEquals('user1', mapping_version.created_by)
self.assertEquals('user1', mapping_version.updated_by)
self.assertEquals(self.source1, mapping_version.parent)
self.assertEquals('Same As', mapping_version.map_type)
self.assertEquals(self.concept1, mapping_version.from_concept)
self.assertEquals(self.concept2, mapping_version.to_concept)
self.assertEquals(self.source1, mapping_version.from_source)
self.assertEquals(self.source1.owner_name, mapping_version.from_source_owner)
self.assertEquals(self.source1.mnemonic, mapping_version.from_source_name)
self.assertEquals(self.source1, mapping_version.get_to_source())
self.assertEquals(self.source1.owner_name, mapping_version.to_source_owner)
self.assertEquals(self.concept2.mnemonic, mapping_version.get_to_concept_code())
self.assertEquals(self.concept2.display_name, mapping_version.get_to_concept_name())
def test_add_duplicate_mapping_reference_different_version_number(self):
source_with_open_mrs, user = self.create_source_and_user_fixture()
collection = create_collection(user, CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept_one, errors) = create_concept(mnemonic="ConceptOne", user=self.user1, source=source_with_open_mrs, names=[
create_localized_text(name='UserOne', locale='es', type='FULLY_SPECIFIED')])
(concept_two, errors) = create_concept(mnemonic="ConceptTwo", user=self.user1, source=source_with_open_mrs, names=[
create_localized_text(name='UserTwo', locale='en', type='FULLY_SPECIFIED')])
mapping = create_mapping(user, source_with_open_mrs, concept_one, concept_two)
kwargs = {'user': user.username, 'collection': collection.name}
data = json.dumps({
'data': {
'expressions': [mapping.url]
}
})
self.client.put(reverse('collection-references', kwargs=kwargs), data,
content_type='application/json')
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
map_type=mapping.map_type,
parent=source_with_open_mrs,
from_concept=concept_two,
to_concept=concept_one,
external_id='mapping1',
versioned_object_id=mapping.id,
versioned_object_type=ContentType.objects.get_for_model(Mapping),
mnemonic='1'
)
mapping_version.full_clean()
mapping_version.save()
data = json.dumps({
'data': {
'expressions': [mapping_version.url]
}
})
response = self.client.put(reverse('collection-references', kwargs=kwargs), data,
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, [{'added': False, 'expression': mapping_version.url,
'message': [REFERENCE_ALREADY_EXISTS]}])
def test_create_mapping_positive(self):
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mappingversion1',
versioned_object_id=self.mapping1.id,
mnemonic='tempid',
versioned_object_type=ContentType.objects.get_for_model(Mapping),
)
mapping_version.full_clean()
mapping_version.save()
self.assertTrue(MappingVersion.objects.filter(versioned_object_id = self.mapping1.id).exists())
mapping_version = MappingVersion.objects.get(versioned_object_id = self.mapping1.id)
self.assertEquals(ACCESS_TYPE_VIEW, mapping_version.public_access)
self.assertEquals('user1', mapping_version.created_by)
self.assertEquals('user1', mapping_version.updated_by)
self.assertEquals(self.source1, mapping_version.parent)
self.assertEquals('Same As', mapping_version.map_type)
self.assertEquals(self.concept1, mapping_version.from_concept)
self.assertEquals(self.concept2, mapping_version.to_concept)
self.assertEquals(self.source1, mapping_version.from_source)
self.assertEquals(self.source1.owner_name, mapping_version.from_source_owner)
self.assertEquals(self.source1.mnemonic, mapping_version.from_source_name)
self.assertEquals(self.source1, mapping_version.get_to_source())
self.assertEquals(self.source1.owner_name, mapping_version.to_source_owner)
self.assertEquals(self.concept2.mnemonic, mapping_version.get_to_concept_code())
self.assertEquals(self.concept2.display_name, mapping_version.get_to_concept_name())
def test_create_mapping_negative__no_version_object(self):
with self.assertRaises(ValidationError):
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
versioned_object_type=ContentType.objects.get_for_model(Mapping),
mnemonic='tempid'
)
mapping_version.full_clean()
mapping_version.save()
def test_should_not_add_related_mapping_if_another_version_is_present_in_collection(self):
source, user = self.create_source_and_user_fixture(custom_validation_schema=None)
collection = create_collection(user)
(from_concept, errors) = create_concept(user=user, source=source, names=[
create_localized_text(name='Non Unique Name', locale_preferred=True, locale='en', type='None'),
create_localized_text(name='Any Name', locale='en', type='Fully Specified')
])
(to_concept, errors) = create_concept(user=user, source=source, names=[
create_localized_text(name='Any Name 2', locale='en', type='Fully Specified')
])
mapping = create_mapping(user, source, from_concept, to_concept)
mapping_first_version = MappingVersion.get_latest_version_of(mapping)
mapping.map_type = "new type"
errors = Mapping.persist_changes(mapping, updated_by=user, update_comment="--")
mapping_head_version = MappingVersion.get_latest_version_of(mapping)
data = json.dumps({
'data': {
'expressions': [mapping_first_version.url]
}
})
kwargs = {'user': user.username, 'collection': collection.name}
response = self.client.put(reverse('collection-references', kwargs=kwargs), data,
content_type='application/json')
data = json.dumps({
'data': {
'expressions': [from_concept.url]
}
})
kwargs = {'user': user.username, 'collection': collection.name}
response = self.client.put(reverse('collection-references', kwargs=kwargs), data,
content_type='application/json')
self.assertEquals(response.content, json.dumps([{
"message": HEAD_OF_CONCEPT_ADDED_TO_COLLECTION,
"added": True,
"expression": from_concept.get_latest_version.url}]))
def test_mapping_access_changes_with_source(self):
public_access = self.source1.public_access
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
public_access=public_access,
external_id='mapping1',
versioned_object_id=self.mapping1.id,
versioned_object_type=ContentType.objects.get_for_model(Mapping),
mnemonic='tempid'
)
mapping_version.full_clean()
mapping_version.save()
self.assertEquals(self.source1.public_access, mapping_version.public_access)
self.source1.public_access = ACCESS_TYPE_VIEW
self.source1.save()
def restore_object(self, attrs, instance=None):
mapping_version = instance if instance else MappingVersion()
mapping_version.map_type = attrs.get('map_type', mapping_version.map_type)
from_concept = None
try:
from_concept = mapping_version.from_concept
except Concept.DoesNotExist: pass
mapping_version.retired = attrs.get('retired', mapping_version.retired)
mapping_version.from_concept = attrs.get('from_concept', from_concept)
mapping_version.to_concept = attrs.get('to_concept', mapping_version.to_concept)
mapping_version.to_source = attrs.get('to_source', mapping_version.to_source)
mapping_version.to_concept_name = attrs.get('to_concept_name', mapping_version.to_concept_name)
mapping_version.to_concept_code = attrs.get('to_concept_code', mapping_version.to_concept_code)
mapping_version.external_id = attrs.get('external_id', mapping_version.external_id)
return mapping_version
def test_create_mapping_negative__no_version_object(self):
with self.assertRaises(ValidationError):
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
external_id='mapping1',
versioned_object_type=ContentType.objects.get_for_model(Mapping),
mnemonic='tempid'
)
mapping_version.full_clean()
mapping_version.save()
def test_mapping_access_changes_with_source(self):
public_access = self.source1.public_access
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
parent=self.source1,
map_type='Same As',
from_concept=self.concept1,
to_concept=self.concept2,
public_access=public_access,
external_id='mapping1',
versioned_object_id=self.mapping1.id,
versioned_object_type=ContentType.objects.get_for_model(Mapping),
mnemonic='tempid'
)
mapping_version.full_clean()
mapping_version.save()
self.assertEquals(self.source1.public_access, mapping_version.public_access)
self.source1.public_access = ACCESS_TYPE_VIEW
self.source1.save()
def test_collections_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, errors) = create_concept(mnemonic='concept12', user=self.user1, source=source)
(from_concept, errors) = create_concept(mnemonic='fromConcept', user=self.user1, source=source)
(to_concept, errors) = create_concept(mnemonic='toConcept', user=self.user1, source=source)
mapping = Mapping(
map_type='Same As',
from_concept=from_concept,
to_concept=to_concept,
external_id='mapping',
)
kwargs = {
'parent_resource': source,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
initial_mapping_version = MappingVersion.objects.get(versioned_object_id=mapping.id)
new_mapping_version = MappingVersion.for_mapping(mapping)
new_mapping_version.mnemonic = 98
new_mapping_version.save()
from_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(mnemonic=from_concept.mnemonic).mnemonic + '/'
concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(mnemonic=concept1.mnemonic).mnemonic + '/'
mapping = Mapping.objects.filter()[1]
references = [concept1_reference, from_concept_reference, mapping.uri, initial_mapping_version.uri]
collection.expressions = references
collection.full_clean()
collection.save()
self.assertEquals(initial_mapping_version.collection_ids, [collection.id])
self.assertEquals(new_mapping_version.collection_ids, [collection.id])
def test_add_duplicate_mapping_reference_different_version_number(self):
source_with_open_mrs, user = self.create_source_and_user_fixture()
collection = create_collection(user, CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept_one, errors) = create_concept(mnemonic="ConceptOne",
user=self.user1,
source=source_with_open_mrs,
names=[
create_localized_text(
name='UserOne',
locale='es',
type='FULLY_SPECIFIED')
])
(concept_two, errors) = create_concept(mnemonic="ConceptTwo",
user=self.user1,
source=source_with_open_mrs,
names=[
create_localized_text(
name='UserTwo',
locale='en',
type='FULLY_SPECIFIED')
])
mapping = create_mapping(user, source_with_open_mrs, concept_one,
concept_two)
kwargs = {'user': user.username, 'collection': collection.name}
data = json.dumps({'data': {'expressions': [mapping.url]}})
self.client.put(reverse('collection-references', kwargs=kwargs),
data,
content_type='application/json')
mapping_version = MappingVersion(
created_by=self.user1,
updated_by=self.user1,
map_type=mapping.map_type,
parent=source_with_open_mrs,
from_concept=concept_two,
to_concept=concept_one,
external_id='mapping1',
versioned_object_id=mapping.id,
versioned_object_type=ContentType.objects.get_for_model(Mapping),
mnemonic='1')
mapping_version.full_clean()
mapping_version.save()
data = json.dumps({'data': {'expressions': [mapping_version.url]}})
response = self.client.put(reverse('collection-references',
kwargs=kwargs),
data,
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, [{
'added': False,
'expression': mapping_version.url,
'message': [REFERENCE_ALREADY_EXISTS]
}])
def test_collections_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='foobar',
from_concept=fromConcept,
to_concept=toConcept,
external_id='mapping',
)
kwargs = {
'parent_resource': source,
}
Mapping.persist_new(mapping, self.user1, **kwargs)
initial_mapping_version = MappingVersion.objects.get(versioned_object_id=mapping.id)
new_mapping_version = MappingVersion.for_mapping(mapping)
new_mapping_version.mnemonic = 98
new_mapping_version.save()
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]
references = [concept1_reference, from_concept_reference, mapping.uri, initial_mapping_version.uri]
collection.expressions = references
collection.full_clean()
collection.save()
self.assertEquals(initial_mapping_version.collection_ids, [collection.id])
self.assertEquals(new_mapping_version.collection_ids, [collection.id])
