def test_import_job_for_change_in_data(self): stdout_stub = TestStream() stderr_stub = TestStream() mapping = Mapping( parent=self.source1, map_type='SAME-AS', from_concept=self.concept3, to_source=self.source1, to_concept_code='413532003', external_id='junk' ) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.mappings = [mapping.id] source_version.save() importer = MappingsImporter(self.source1, self.testfile, stdout_stub, stderr_stub, 'test') importer.import_mappings(total=1) self.assertTrue('mappings of 1 1 - 1 updated' in stdout_stub.getvalue()) self.assertTrue(('Updated mapping with ID ' + mapping.id) in stdout_stub.getvalue()) updated_mapping = Mapping.objects.get(to_concept_code='413532003') self.assertTrue(updated_mapping.retired) self.assertEquals(updated_mapping.external_id, '70279ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBB')
def test_persist_persist_changes_positive(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) mapping = Mapping.objects.get(external_id='mapping1') to_concept = mapping.to_concept source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings) mapping.to_concept = self.concept3 errors = Mapping.persist_changes(mapping, self.user1) self.assertEquals(0, len(errors)) mapping = Mapping.objects.get(external_id='mapping1') self.assertEquals(self.concept3, mapping.to_concept) self.assertNotEquals(to_concept, mapping.to_concept) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) mv = MappingVersion.objects.filter(versioned_object_id=mapping.id) self.assertTrue(mv[1].id in source_version.mappings)
def test_persist_persist_changes_negative__no_updated_by(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) mapping = Mapping.objects.get(external_id='mapping1') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings) mapping.to_concept = self.concept3 errors = Mapping.persist_changes(mapping, None) self.assertEquals(1, len(errors)) self.assertTrue('updated_by' in errors) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
def test_import_job_for_change_in_data(self): stdout_stub = TestStream() stderr_stub = TestStream() mapping = Mapping(parent=self.source1, map_type='SAME-AS', from_concept=self.concept3, to_source=self.source1, to_concept_code='413532003', external_id='junk') kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.mappings = [mapping.id] source_version.save() importer = MappingsImporter(self.source1, self.testfile, stdout_stub, stderr_stub, 'test') importer.import_mappings(total=1) self.assertTrue('**** Processed 1 out of 1 mappings - 1 updated, ****' in stdout_stub.getvalue()) self.assertTrue(('Updated mapping with ID ' + mapping.id) in stdout_stub.getvalue()) updated_mapping = Mapping.objects.get(to_concept_code='413532003') self.assertTrue(updated_mapping.retired) self.assertEquals(updated_mapping.external_id, '70279ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBB')
def test_import_job_for_change_in_data(self): stdout_stub = TestStream() stderr_stub = TestStream() mapping = Mapping( parent=self.source1, map_type="SAME-AS", from_concept=self.concept3, to_source=self.source1, to_concept_code="413532003", external_id="junk", ) kwargs = {"parent_resource": self.source1} Mapping.persist_new(mapping, self.user1, **kwargs) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.mappings = [mapping.id] source_version.save() importer = MappingsImporter(self.source1, self.testfile, stdout_stub, stderr_stub, "test") importer.import_mappings(total=1) self.assertTrue("**** Processed 1 out of 1 mappings - 1 updated, ****" in stdout_stub.getvalue()) self.assertTrue(("Updated mapping with ID " + mapping.id) in stdout_stub.getvalue()) updated_mapping = Mapping.objects.get(to_concept_code="413532003") self.assertTrue(updated_mapping.retired) self.assertEquals(updated_mapping.external_id, "70279ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBB")
def create_mapping(user, source, from_concept, to_concept, map_type="SAME-AS", mnemonic=None): mapping = None if mnemonic: mapping = Mapping( mnemonic=mnemonic, created_by=user, updated_by=user, parent=source, map_type=map_type, from_concept=from_concept, to_concept=to_concept, public_access=ACCESS_TYPE_VIEW, ) else: mapping = Mapping( created_by=user, updated_by=user, parent=source, map_type=map_type, from_concept=from_concept, to_concept=to_concept, public_access=ACCESS_TYPE_VIEW, ) kwargs = { 'parent_resource': source, } Mapping.persist_new(mapping, user, **kwargs) return Mapping.objects.get(id=mapping.id)
def test_persist_new_positive__same_mapping_different_source(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue( Mapping.objects.filter(external_id='mapping1').exists()) mapping = Mapping.objects.get(external_id='mapping1') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue( MappingVersion.objects.get( versioned_object_id=mapping.id).id in source_version.mappings) # Repeat with same concepts mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping2', ) kwargs = { 'parent_resource': self.source2, } source_version = SourceVersion.get_latest_version_of(self.source2) self.assertEquals(0, len(source_version.mappings)) errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue( Mapping.objects.filter(external_id='mapping2').exists()) mapping = Mapping.objects.get(external_id='mapping2') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue( MappingVersion.objects.get( versioned_object_id=mapping.id).id in source_version.mappings)
def test_persist_new_positive(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists()) mapping = Mapping.objects.get(external_id='mapping1') self.assertEquals(self.source1.public_access, mapping.public_access) self.assertEquals('user1', mapping.created_by) self.assertEquals('user1', mapping.updated_by) self.assertEquals(self.source1, mapping.parent) self.assertEquals('Same As', mapping.map_type) self.assertEquals(self.concept1, mapping.from_concept) self.assertEquals(self.concept2, mapping.to_concept) self.assertEquals(self.source1, mapping.from_source) self.assertEquals(self.source1.owner_name, mapping.from_source_owner) self.assertEquals(self.source1.mnemonic, mapping.from_source_name) self.assertEquals(self.source1, mapping.get_to_source()) self.assertEquals(self.source1.owner_name, mapping.to_source_owner) self.assertEquals(self.concept2.mnemonic, mapping.get_to_concept_code()) self.assertEquals(self.concept2.display_name, mapping.get_to_concept_name()) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
def test_edit_mapping_make_new_version_positive(self): mapping1 = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping1, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertEquals(1,len(MappingVersion.objects.filter(versioned_object_id=mapping1.id))) mapping1.map_type='BROADER_THAN' Mapping.persist_changes(mapping1, self.user1) self.assertEquals(2, len(MappingVersion.objects.filter(versioned_object_id=mapping1.id))) old_version = MappingVersion.objects.get(versioned_object_id=mapping1.id, is_latest_version=False) new_version= MappingVersion.objects.get(versioned_object_id=mapping1.id, is_latest_version=True) self.assertFalse(old_version.is_latest_version) self.assertTrue(new_version.is_latest_version) self.assertEquals(new_version.map_type,'BROADER_THAN') self.assertEquals(old_version.map_type,'Same As')
def test_persist_new_positive__earlier_source_version(self): version1 = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(version1.mappings)) version2 = SourceVersion.for_base_object(self.source1, label='version2') version2.save() self.assertEquals(0, len(version2.mappings)) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) kwargs = { 'parent_resource': self.source1, 'parent_resource_version': version1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists()) mapping = Mapping.objects.get(external_id='mapping1') version1 = SourceVersion.objects.get(id=version1.id) self.assertEquals(1, len(version1.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in version1.mappings) version2 = SourceVersion.objects.get(id=version2.id) self.assertEquals(0, len(version2.mappings)) latest_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(latest_version.mappings))
def create_mapping(user, source, from_concept, to_concept, map_type="Same As"): mapping = Mapping( created_by=user, updated_by=user, parent=source, map_type=map_type, from_concept=from_concept, to_concept=to_concept, public_access=ACCESS_TYPE_VIEW, ) kwargs = {"parent_resource": source} Mapping.persist_new(mapping, user, **kwargs) return Mapping.objects.get(id=mapping.id)
def test_create_same_from_and_to_pair_with_different_map_types_should_throw_validation_error(self): user = create_user() source = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS) (concept1, _) = create_concept(user, source) (concept2, _) = create_concept(user, source) create_mapping(user, source, concept1, concept2, "Same As") mapping = Mapping( created_by=user, updated_by=user, parent=source, map_type='Is Subset of', from_concept=concept1, to_concept=concept2, public_access=ACCESS_TYPE_VIEW, ) kwargs = { 'parent_resource': source, } errors = Mapping.persist_new(mapping, user, **kwargs) self.assertTrue(OPENMRS_SINGLE_MAPPING_BETWEEN_TWO_CONCEPTS in errors["__all__"])
def test_create_mapping_positive__valid_mapping_type(self): maptypes_source = Source.objects.get(name="MapTypes") create_concept(self.user1, maptypes_source, concept_class="MapType", names=[create_localized_text("SAME-AS")]) create_concept(self.user1, maptypes_source, concept_class="MapType", names=[create_localized_text("NARROWER-THAN")]) user = create_user() source = create_source(user) (concept1, _) = create_concept(user, source) (concept2, _) = create_concept(user, source) mapping = Mapping( created_by=user, updated_by=user, parent=source, map_type='SAME-AS', from_concept=concept1, to_concept=concept2, public_access=ACCESS_TYPE_VIEW, ) kwargs = { 'parent_resource': source, } errors = Mapping.persist_new(mapping, user, **kwargs) self.assertEquals(0, len(errors))
def test_update_mapping_with_invalid_record(self): mapping = Mapping(parent=self.source1, map_type="SAME-AS", from_concept=self.concept3, to_concept=self.concept1) kwargs = {"parent_resource": self.source1} Mapping.persist_new(mapping, self.user1, **kwargs) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.mappings = [mapping.id] source_version.save() stderr_stub = TestStream() invalid_json_file = open("./integration_tests/fixtures/one_internal_invalid_mapping.json", "rb") importer = MappingsImporter(self.source1, invalid_json_file, TestStream(), stderr_stub, "test") importer.import_mappings(total=1) self.assertTrue( "Must specify either 'to_concept' or 'to_source' & 'to_concept_code'. Cannot specify both." in stderr_stub.getvalue() )
def test_retire_positive(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) mapping = Mapping.objects.get(external_id='mapping1') self.assertFalse(mapping.retired) retired = Mapping.retire(mapping, self.user1) self.assertTrue(retired) mapping = Mapping.objects.get(external_id='mapping1') self.assertTrue(mapping.retired)
def create_mapping(user, source, from_concept, to_concept, map_type="Same As"): mapping = Mapping( created_by=user, updated_by=user, parent=source, map_type=map_type, from_concept=from_concept, to_concept=to_concept, public_access=ACCESS_TYPE_VIEW, ) kwargs = { 'parent_resource': source, } Mapping.persist_new(mapping, user, **kwargs) return Mapping.objects.get(id=mapping.id)
def test_persist_new_positive__same_mapping_different_source(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists()) mapping = Mapping.objects.get(external_id='mapping1') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings) # Repeat with same concepts mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping2', ) kwargs = { 'parent_resource': self.source2, } source_version = SourceVersion.get_latest_version_of(self.source2) self.assertEquals(0, len(source_version.mappings)) errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Mapping.objects.filter(external_id='mapping2').exists()) mapping = Mapping.objects.get(external_id='mapping2') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) self.assertTrue(MappingVersion.objects.get(versioned_object_id=mapping.id).id in source_version.mappings)
def test_retire_negative(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', retired=True, ) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) mapping = Mapping.objects.get(external_id='mapping1') self.assertTrue(mapping.retired) result=Mapping.retire(mapping, self.user1) self.assertFalse(result) mapping = Mapping.objects.get(external_id='mapping1') self.assertTrue(mapping.retired)
def test_retire_positive(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) mapping = Mapping.objects.get(external_id='mapping1') self.assertFalse(mapping.retired) Mapping.retire(mapping, self.user1) self.assertTrue(mapping.retired) mapping = Mapping.objects.get(external_id='mapping1') self.assertTrue(mapping.retired) mappingVersion=MappingVersion.objects.get(versioned_object_id=mapping.mnemonic, mnemonic=2) self.assertTrue(mappingVersion.retired)
def test_persist_new_negative__same_mapping(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue( Mapping.objects.filter(external_id='mapping1').exists()) mapping = Mapping.objects.get(external_id='mapping1') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) mv = MappingVersion.objects.get(versioned_object_id=mapping.id) self.assertTrue(mv.id in source_version.mappings) # Repeat with same concepts mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping2', ) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(1, len(errors)) self.assertEquals(1, len(errors)) self.assertTrue('__all__' in errors) non_field_errors = errors['__all__'] self.assertEquals(1, len(non_field_errors)) self.assertTrue('already exists' in non_field_errors[0]) self.assertEquals(1, len(source_version.mappings))
def test_create_mapping_negative__no_parent(self): mapping = Mapping( created_by=self.user1, updated_by=self.user1, map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) errors = Mapping.persist_new(mapping, self.user1) self.assertTrue(errors)
def test_persist_new_negative__same_mapping(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(0, len(errors)) self.assertTrue(Mapping.objects.filter(external_id='mapping1').exists()) mapping = Mapping.objects.get(external_id='mapping1') source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(1, len(source_version.mappings)) mv = MappingVersion.objects.get(versioned_object_id=mapping.id) self.assertTrue(mv.id in source_version.mappings) # Repeat with same concepts mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping2', ) kwargs = { 'parent_resource': self.source1, } errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(1, len(errors)) self.assertEquals(1, len(errors)) self.assertTrue('__all__' in errors) non_field_errors = errors['__all__'] self.assertEquals(1, len(non_field_errors)) self.assertTrue('already exists' in non_field_errors[0]) self.assertEquals(1, len(source_version.mappings))
def test_update_mapping_with_invalid_record(self): mapping = Mapping(parent=self.source1, map_type='SAME-AS', from_concept=self.concept3, to_concept=self.concept1) kwargs = { 'parent_resource': self.source1, } Mapping.persist_new(mapping, self.user1, **kwargs) source_version = SourceVersion.get_latest_version_of(self.source1) source_version.mappings = [mapping.id] source_version.save() stderr_stub = TestStream() invalid_json_file = open( './integration_tests/fixtures/one_internal_invalid_mapping.json', 'rb') importer = MappingsImporter(self.source1, invalid_json_file, TestStream(), stderr_stub, 'test') importer.import_mappings(total=1) self.assertTrue( "Must specify either 'to_concept' or 'to_source' & 'to_concept_code'. Cannot specify both." in stderr_stub.getvalue())
def add_mapping(self, data): """ Create a new mapping """ # Create the new mapping mapping = Mapping(**data) kwargs = {'parent_resource': self.source} if self.test_mode: mapping.save=lambda x: None errors = Mapping.persist_new(mapping, self.user, **kwargs) if errors: raise IllegalInputException( 'Could not persist new mapping due to %s' % errors) return ImportActionHelper.IMPORT_ACTION_ADD
def test_persist_new_negative__no_parent(self): mapping = Mapping( map_type='Same As', from_concept=self.concept1, to_concept=self.concept2, external_id='mapping1', ) source_version = SourceVersion.get_latest_version_of(self.source1) self.assertEquals(0, len(source_version.mappings)) kwargs = {} errors = Mapping.persist_new(mapping, self.user1, **kwargs) self.assertEquals(1, len(errors)) self.assertTrue('non_field_errors' in errors) non_field_errors = errors['non_field_errors'] self.assertEquals(1, len(non_field_errors)) self.assertTrue('parent' in non_field_errors[0]) self.assertFalse(Mapping.objects.filter(external_id='mapping1').exists()) source_version = SourceVersion.objects.get(id=source_version.id) self.assertEquals(0, len(source_version.mappings))
def save_object(self, obj, **kwargs): request_user = self.context['request'].user errors = Mapping.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_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_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, 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) 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])