def copy_resource_task(ori_res_id, new_res_id=None, request_username=None): try: new_res = None if not new_res_id: new_res = create_empty_resource(ori_res_id, request_username, action='copy') new_res_id = new_res.short_id utils.copy_resource_files_and_AVUs(ori_res_id, new_res_id) ori_res = utils.get_resource_by_shortkey(ori_res_id) if not new_res: new_res = utils.get_resource_by_shortkey(new_res_id) utils.copy_and_create_metadata(ori_res, new_res) hs_identifier = ori_res.metadata.identifiers.all().filter( name="hydroShareIdentifier")[0] if hs_identifier: new_res.metadata.create_element('source', derived_from=hs_identifier.url) if ori_res.resource_type.lower() == "collectionresource": # clone contained_res list of original collection and add to new collection # note that new collection will not contain "deleted resources" new_res.resources = ori_res.resources.all() # create bag for the new resource create_bag(new_res) return new_res.get_absolute_url() except Exception as ex: if new_res: new_res.delete() raise utils.ResourceCopyException(str(ex))
def test_copy(self): # create 1 SupportedResTypes obj with required params resource.create_metadata_element( self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # set url launching pattern for aggregations metadata = [{ 'requesturlbaseaggregation': { 'value': 'https://www.google.com?agg_path=${HS_AGG_PATH}' } }] self.resWebApp.metadata.update(metadata, self.user) resource.create_metadata_element( self.resWebApp.short_id, 'SupportedAggTypes', supported_agg_types=['GeoRasterLogicalFile']) self.assertEqual(1, SupportedAggTypes.objects.all().count()) # make a new copy of web app new_web_app = create_empty_resource(self.resWebApp.short_id, self.user, action='copy') new_web_app = copy_resource(self.resWebApp, new_web_app) # test the new copy is a web app self.assertTrue(isinstance(new_web_app, ToolResource)) # test that added types are copied self.assertEqual(2, SupportedResTypes.objects.all().count()) self.assertEqual(2, SupportedAggTypes.objects.all().count())
def test_copy(self): # no contained resource self.assertEqual(self.resCollection.resources.count(), 0) # add 3 resources to collection self.resCollection.resources.add(self.resGen1) self.resCollection.resources.add(self.resGeoFeature) self.resCollection.resources.add(self.resCollection_with_missing_metadata) self.assertEqual(self.resCollection.resources.count(), 3) # make a new copy of collection new_collection = create_empty_resource(self.resCollection.short_id, self.user1, action='copy') new_collection = copy_resource(self.resCollection, new_collection) # test the new copy is a collection self.assertTrue(isinstance(new_collection, CollectionResource)) # new copy collection should have same contained res as its original does self.assertEqual(new_collection.resources.count(), self.resCollection.resources.count()) for contained_res in new_collection.resources.all(): self.assertIn(contained_res, self.resCollection.resources.all()) # changes to old collection should not affect new copied collection self.resCollection.resources.clear() self.assertEqual(self.resCollection.resources.count(), 0) self.assertEqual(new_collection.resources.count(), 3)
def test_copy(self): # create 1 SupportedResTypes obj with required params resource.create_metadata_element(self.resWebApp.short_id, 'SupportedResTypes', supported_res_types=['NetcdfResource']) self.assertEqual(SupportedResTypes.objects.all().count(), 1) # set url launching pattern for aggregations metadata = [{'requesturlbaseaggregation': { 'value': 'https://www.google.com?agg_path=${HS_AGG_PATH}'}}] self.resWebApp.metadata.update(metadata, self.user) resource.create_metadata_element(self.resWebApp.short_id, 'SupportedAggTypes', supported_agg_types=['GeoRasterLogicalFile']) self.assertEqual(1, SupportedAggTypes.objects.all().count()) # make a new copy of web app new_web_app = create_empty_resource(self.resWebApp.short_id, self.user, action='copy') new_web_app = copy_resource(self.resWebApp, new_web_app) # test the new copy is a web app self.assertTrue(isinstance(new_web_app, ToolResource)) # test that added types are copied self.assertEqual(2, SupportedResTypes.objects.all().count()) self.assertEqual(2, SupportedAggTypes.objects.all().count())
def setUp(self): super(TestHideOldVersions, self).setUp() self.group, _ = Group.objects.get_or_create(name='Hydroshare Author') # create a user who is the owner of the resource to be versioned self.owner = hydroshare.create_account('*****@*****.**', username='******', first_name='owner_firstname', last_name='owner_lastname', superuser=False, groups=[]) # create a generic resource self.version0 = hydroshare.create_resource( resource_type='CompositeResource', owner=self.owner, title='Test Composite Resource') test_file1 = open('test1.txt', 'w') test_file1.write("Test text file in test1.txt") test_file1.close() test_file2 = open('test2.txt', 'w') test_file2.write("Test text file in test2.txt") test_file2.close() self.test_file1 = open('test1.txt', 'rb') self.test_file2 = open('test2.txt', 'rb') hydroshare.add_resource_files(self.version0.short_id, self.test_file1, self.test_file2) # make one version self.version1 = hydroshare.create_empty_resource( self.version0.short_id, self.owner) self.version1 = hydroshare.create_new_version_resource( self.version0, self.version1, self.owner) # and then make a version of that self.version2 = hydroshare.create_empty_resource( self.version1.short_id, self.owner) self.version2 = hydroshare.create_new_version_resource( self.version1, self.version2, self.owner)
def test_new_version_generic_resource(self): # test to make sure only owners can version a resource with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner) self.owner.uaccess.share_resource_with_user(self.res_generic, self.nonowner, PrivilegeCodes.CHANGE) with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner) self.owner.uaccess.share_resource_with_user(self.res_generic, self.nonowner, PrivilegeCodes.VIEW) with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner) # add key/value metadata to original resource self.res_generic.extra_metadata = {'variable': 'temp', 'units': 'deg F'} self.res_generic.save() new_res_generic = hydroshare.create_empty_resource(self.res_generic.short_id, self.owner) # test to make sure the new versioned empty resource has no content files self.assertEqual(new_res_generic.files.all().count(), 0) new_res_generic = hydroshare.create_new_version_resource(self.res_generic, new_res_generic, self.owner) # test the new versioned resource has the same resource type as the original resource self.assertTrue(isinstance(new_res_generic, GenericResource)) # test the new versioned resource has the correct content file with correct path copied over self.assertEqual(new_res_generic.files.all().count(), 2) # add each file of resource to list new_res_file_list = [] for f in new_res_generic.files.all(): new_res_file_list.append(f.resource_file.name) for f in self.res_generic.files.all(): ori_res_no_id_file_path = f.resource_file.name[len(self.res_generic.short_id):] new_res_file_path = new_res_generic.short_id + ori_res_no_id_file_path self.assertIn(new_res_file_path, new_res_file_list, msg='resource content path is not created correctly ' 'for new versioned resource') # test key/value metadata copied over self.assertEqual(new_res_generic.extra_metadata, self.res_generic.extra_metadata) # test science metadata elements are copied from the original resource to the new versioned # resource self.assertEqual(new_res_generic.metadata.title.value, self.res_generic.metadata.title.value, msg='metadata title is not copied over to the new versioned resource') self.assertEqual(new_res_generic.creator, self.owner, msg='creator is not copied over to the new versioned resource') # test to make sure a new unique identifier has been created for the new versioned resource self.assertIsNotNone( new_res_generic.short_id, msg='Unique identifier has not been created for new versioned resource.') self.assertNotEqual(new_res_generic.short_id, self.res_generic.short_id) # test to make sure the new versioned resource has the correct identifier self.assertEqual(new_res_generic.metadata.identifiers.all().count(), 1, msg="Number of identifier elements not equal to 1.") self.assertIn('hydroShareIdentifier', [id.name for id in new_res_generic.metadata.identifiers.all()], msg="hydroShareIdentifier name was not found for new versioned resource.") id_url = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_generic.short_id) self.assertIn(id_url, [id.url for id in new_res_generic.metadata.identifiers.all()], msg="Identifier url was not found for new versioned resource.") # test to make sure the new versioned resource is linked with the original resource via # isReplacedBy and isVersionOf metadata elements self.assertGreater(new_res_generic.metadata.relations.all().count(), 0, msg="New versioned resource does has relation element.") self.assertIn('isVersionOf', [rel.type for rel in new_res_generic.metadata.relations.all()], msg="No relation element of type 'isVersionOf' for new versioned resource") version_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), self.res_generic.short_id) self.assertIn(version_value, [rel.value for rel in new_res_generic.metadata.relations.all()], msg="The original resource identifier is not set as value for isVersionOf " "for new versioned resource.") self.assertIn('isReplacedBy', [rel.type for rel in self.res_generic.metadata.relations.all()], msg="No relation element of type 'isReplacedBy' for the original resource") version_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_generic.short_id) self.assertIn(version_value, [rel.value for rel in self.res_generic.metadata.relations.all()], msg="The new versioned resource identifier is not set as value for " "isReplacedBy for original resource.") # test isReplacedBy is removed after the new versioned resource is deleted hydroshare.delete_resource(new_res_generic.short_id) self.assertNotIn('isReplacedBy', [rel.type for rel in self.res_generic.metadata.relations.all()], msg="isReplacedBy is not removed from the original resource after " "its versioned resource is deleted") # delete the original resource to make sure iRODS files are cleaned up hydroshare.delete_resource(self.res_generic.short_id)
def test_new_version_raster_resource(self): # test to make sure only owners can version a resource with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_raster.short_id, self.nonowner) self.owner.uaccess.share_resource_with_user(self.res_raster, self.nonowner, PrivilegeCodes.CHANGE) with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_raster.short_id, self.nonowner) self.owner.uaccess.share_resource_with_user(self.res_raster, self.nonowner, PrivilegeCodes.VIEW) with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_raster.short_id, self.nonowner) new_res_raster = hydroshare.create_empty_resource(self.res_raster.short_id, self.owner) new_res_raster = hydroshare.create_new_version_resource(self.res_raster, new_res_raster, self.owner) # test the new versioned resource has the same resource type as the original resource self.assertTrue(isinstance(new_res_raster, RasterResource)) # test science metadata elements are copied from the original resource to the new versioned # resource self.assertTrue(new_res_raster.metadata.title.value == self.res_raster.metadata.title.value) self.assertTrue(new_res_raster.creator == self.owner) # test extended metadata elements are copied from the original resource to the new # versioned resource self.assertTrue(OriginalCoverage.objects.filter( object_id=new_res_raster.metadata.id).exists()) self.assertEqual(new_res_raster.metadata.originalCoverage.value, self.res_raster.metadata.originalCoverage.value, msg="OriginalCoverage of new versioned resource is not equal to " "that of the original resource") self.assertTrue(CellInformation.objects.filter( object_id=new_res_raster.metadata.id).exists()) newcell = new_res_raster.metadata.cellInformation oldcell = self.res_raster.metadata.cellInformation self.assertEqual(newcell.rows, oldcell.rows, msg="Rows of new versioned resource is not equal to that of " "the original resource") self.assertEqual(newcell.columns, oldcell.columns, msg="Columns of new versioned resource is not equal to that of the " "original resource") self.assertEqual(newcell.cellSizeXValue, oldcell.cellSizeXValue, msg="CellSizeXValue of new versioned resource is not equal to " "that of the original resource") self.assertEqual(newcell.cellSizeYValue, oldcell.cellSizeYValue, msg="CellSizeYValue of new versioned resource is not equal to " "that of the original resource") self.assertEqual(newcell.cellDataType, oldcell.cellDataType, msg="CellDataType of new versioned resource is not equal to " "that of the original resource") self.assertTrue(BandInformation.objects.filter( object_id=new_res_raster.metadata.id).exists()) newband = new_res_raster.metadata.bandInformations.first() oldband = self.res_raster.metadata.bandInformations.first() self.assertEqual(newband.name, oldband.name, msg="Band name of new versioned resource is not equal to that of " "the original resource") # test to make sure a new unique identifier has been created for the new versioned resource self.assertIsNotNone(new_res_raster.short_id, msg='Unique identifier has not been ' 'created for new versioned resource.') self.assertNotEqual(new_res_raster.short_id, self.res_raster.short_id) # test to make sure the new versioned resource has 2 content file # since an additional vrt file is created self.assertEqual(new_res_raster.files.all().count(), 2) # test to make sure the new versioned resource has the correct identifier self.assertEqual(new_res_raster.metadata.identifiers.all().count(), 1, msg="Number of identifier elements not equal to 1.") self.assertIn('hydroShareIdentifier', [id.name for id in new_res_raster.metadata.identifiers.all()], msg="hydroShareIdentifier name was not found for new versioned resource.") id_url = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_raster.short_id) self.assertIn(id_url, [id.url for id in new_res_raster.metadata.identifiers.all()], msg="Identifier url was not found for new versioned resource.") # test to make sure the new versioned resource is linked with the original resource via # isReplacedBy and isVersionOf metadata elements self.assertGreater(new_res_raster.metadata.relations.all().count(), 0, msg="New versioned resource does has relation element.") self.assertIn('isVersionOf', [rel.type for rel in new_res_raster.metadata.relations.all()], msg="No relation element of type 'isVersionOf' for new versioned resource") version_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), self.res_raster.short_id) self.assertIn(version_value, [rel.value for rel in new_res_raster.metadata.relations.all()], msg="The original resource identifier is not set as value " "for isVersionOf for new versioned resource.") self.assertIn('isReplacedBy', [rel.type for rel in self.res_raster.metadata.relations.all()], msg="No relation element of type 'isReplacedBy' for the original resource") version_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_raster.short_id) self.assertIn(version_value, [rel.value for rel in self.res_raster.metadata.relations.all()], msg="The new versioned resource identifier is not set as value " "for isReplacedBy for original resource.") # test isReplacedBy is removed after the new versioned resource is deleted hydroshare.delete_resource(new_res_raster.short_id) self.assertNotIn('isReplacedBy', [rel.type for rel in self.res_raster.metadata.relations.all()], msg="isReplacedBy is not removed from the original resource " "after its versioned resource is deleted") # delete the original resource to make sure iRODS files are cleaned up hydroshare.delete_resource(self.res_raster.short_id)
def test_resource_operations_in_user_zone(self): # only do federation testing when REMOTE_USE_IRODS is True and irods docker containers # are set up properly if not super(TestUserZoneIRODSFederation, self).is_federated_irods_available(): return # test resource creation and "move" option in federated user zone fed_test_file_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_to_be_deleted) res = resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Test Generic Resource in User Zone', source_names=[fed_test_file_full_path], move=True) self.assertEqual(res.files.all().count(), 1, msg="Number of content files is not equal to 1") fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) user_path = '/{zone}/home/testuser/'.format( zone=settings.HS_USER_IRODS_ZONE) self.assertEqual(res.resource_federation_path, fed_path) # test original file in user test zone is removed after resource creation # since True is used for move when creating the resource self.assertFalse( self.irods_storage.exists(user_path + self.file_to_be_deleted)) # test resource file deletion res.files.all().delete() self.assertEqual(res.files.all().count(), 0, msg="Number of content files is not equal to 0") # test add multiple files and 'copy' option in federated user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) fed_test_file2_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_two) hydroshare.add_resource_files( res.short_id, source_names=[fed_test_file1_full_path, fed_test_file2_full_path], move=False) # test resource has two files self.assertEqual(res.files.all().count(), 2, msg="Number of content files is not equal to 2") file_list = [] for f in res.files.all(): file_list.append(f.storage_path.split('/')[-1]) self.assertTrue( self.file_one in file_list, msg='file 1 has not been added in the resource in user zone') self.assertTrue( self.file_two in file_list, msg='file 2 has not been added in the resource in user zone') # test original two files in user test zone still exist after adding them to the resource # since False is used for move when creating the resource self.assertTrue(self.irods_storage.exists(user_path + self.file_one)) self.assertTrue(self.irods_storage.exists(user_path + self.file_two)) # test resource deletion resource.delete_resource(res.short_id) self.assertEquals(BaseResource.objects.all().count(), 0, msg='Number of resources not equal to 0') # test create new version resource in user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) ori_res = resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_test_file1_full_path], move=False) # make sure ori_res is created in federated user zone fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(ori_res.resource_federation_path, fed_path) self.assertEqual(ori_res.files.all().count(), 1, msg="Number of content files is not equal to 1") new_res = hydroshare.create_empty_resource(ori_res.short_id, self.user) new_res = hydroshare.create_new_version_resource( ori_res, new_res, self.user) # only need to test file-related attributes # ensure new versioned resource is created in the same federation zone as original resource self.assertEqual(ori_res.resource_federation_path, new_res.resource_federation_path) # ensure new versioned resource has the same number of content files as original resource self.assertEqual(ori_res.files.all().count(), new_res.files.all().count()) # delete resources to clean up resource.delete_resource(new_res.short_id) resource.delete_resource(ori_res.short_id) # test copy resource in user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) ori_res = resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_test_file1_full_path], move=False) # make sure ori_res is created in federated user zone fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(ori_res.resource_federation_path, fed_path) self.assertEqual(ori_res.files.all().count(), 1, msg="Number of content files is not equal to 1") new_res = hydroshare.create_empty_resource(ori_res.short_id, self.user, action='copy') new_res = hydroshare.copy_resource(ori_res, new_res) # only need to test file-related attributes # ensure new copied resource is created in the same federation zone as original resource self.assertEqual(ori_res.resource_federation_path, new_res.resource_federation_path) # ensure new copied resource has the same number of content files as original resource self.assertEqual(ori_res.files.all().count(), new_res.files.all().count()) # delete resources to clean up resource.delete_resource(new_res.short_id) resource.delete_resource(ori_res.short_id) # test folder operations in user zone fed_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) fed_file2_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_two) fed_file3_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_three) self.res = resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[ fed_file1_full_path, fed_file2_full_path, fed_file3_full_path ], move=False) # make sure self.res is created in federated user zone fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(self.res.resource_federation_path, fed_path) # resource should has only three files at this point self.assertEqual(self.res.files.all().count(), 3, msg="resource file count didn't match") self.file_name_list = [self.file_one, self.file_two, self.file_three] super(TestUserZoneIRODSFederation, self).resource_file_oprs() # delete resources to clean up resource.delete_resource(self.res.short_id) # test adding files from federated user zone to an empty resource # created in hydroshare zone res = resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Test Generic Resource in HydroShare Zone') self.assertEqual(res.files.all().count(), 0, msg="Number of content files is not equal to 0") fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) hydroshare.add_resource_files(res.short_id, source_names=[fed_test_file1_full_path], move=False) # test resource has one file self.assertEqual(res.files.all().count(), 1, msg="Number of content files is not equal to 1") file_list = [] for f in res.files.all(): file_list.append(os.path.basename(f.storage_path)) self.assertTrue( self.file_one in file_list, msg='file 1 has not been added in the resource in hydroshare zone') # test original file in user test zone still exist after adding it to the resource # since 'copy' is used for fed_copy_or_move when adding the file to the resource self.assertTrue(self.irods_storage.exists(user_path + self.file_one)) # test replication of this resource to user zone hydroshare.replicate_resource_bag_to_user_zone(self.user, res.short_id) self.assertTrue(self.irods_storage.exists(user_path + res.short_id + '.zip'), msg='replicated resource bag is not in the user zone') # test resource deletion resource.delete_resource(res.short_id) self.assertEquals(BaseResource.objects.all().count(), 0, msg='Number of resources not equal to 0') # test to make sure original file still exist after resource deletion self.assertTrue(self.irods_storage.exists(user_path + self.file_one))
def test_new_version_generic_resource(self): # test to make sure only owners can version a resource with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner) self.owner.uaccess.share_resource_with_user(self.res_generic, self.nonowner, PrivilegeCodes.CHANGE) with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner) self.owner.uaccess.share_resource_with_user(self.res_generic, self.nonowner, PrivilegeCodes.VIEW) with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner) # add key/value metadata to original resource self.res_generic.extra_metadata = {'variable': 'temp', 'units': 'deg F'} self.res_generic.save() # print("res_generic.files are:") # for f in self.res_generic.files.all(): # print(f.storage_path) new_res_generic = hydroshare.create_empty_resource(self.res_generic.short_id, self.owner) # test to make sure the new versioned empty resource has no content files self.assertEqual(new_res_generic.files.all().count(), 0) new_res_generic = hydroshare.create_new_version_resource(self.res_generic, new_res_generic, self.owner) # test the new versioned resource has the same resource type as the original resource self.assertTrue(isinstance(new_res_generic, GenericResource)) # test the new versioned resource has the correct content file with correct path copied over # print("new_res_generic.files are:") # for f in new_res_generic.files.all(): # print(f.storage_path) self.assertEqual(new_res_generic.files.all().count(), 2) # add each file of resource to list new_res_file_list = [] # TODO: revise for new file handling for f in new_res_generic.files.all(): new_res_file_list.append(f.resource_file.name) for f in self.res_generic.files.all(): ori_res_no_id_file_path = f.resource_file.name[len(self.res_generic.short_id):] new_res_file_path = new_res_generic.short_id + ori_res_no_id_file_path self.assertIn(new_res_file_path, new_res_file_list, msg='resource content path is not created correctly ' 'for new versioned resource') # test key/value metadata copied over self.assertEqual(new_res_generic.extra_metadata, self.res_generic.extra_metadata) # test science metadata elements are copied from the original resource to the new versioned # resource self.assertEqual(new_res_generic.metadata.title.value, self.res_generic.metadata.title.value, msg='metadata title is not copied over to the new versioned resource') self.assertEqual(new_res_generic.creator, self.owner, msg='creator is not copied over to the new versioned resource') # test to make sure a new unique identifier has been created for the new versioned resource self.assertIsNotNone( new_res_generic.short_id, msg='Unique identifier has not been created for new versioned resource.') self.assertNotEqual(new_res_generic.short_id, self.res_generic.short_id) # test to make sure the new versioned resource has the correct identifier self.assertEqual(new_res_generic.metadata.identifiers.all().count(), 1, msg="Number of identifier elements not equal to 1.") self.assertIn('hydroShareIdentifier', [id.name for id in new_res_generic.metadata.identifiers.all()], msg="hydroShareIdentifier name was not found for new versioned resource.") id_url = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_generic.short_id) self.assertIn(id_url, [id.url for id in new_res_generic.metadata.identifiers.all()], msg="Identifier url was not found for new versioned resource.") # test to make sure the new versioned resource is linked with the original resource via # isReplacedBy and isVersionOf metadata elements self.assertGreater(new_res_generic.metadata.relations.all().count(), 0, msg="New versioned resource does has relation element.") self.assertIn('isVersionOf', [rel.type for rel in new_res_generic.metadata.relations.all()], msg="No relation element of type 'isVersionOf' for new versioned resource") version_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), self.res_generic.short_id) self.assertIn(version_value, [rel.value for rel in new_res_generic.metadata.relations.all()], msg="The original resource identifier is not set as value for isVersionOf " "for new versioned resource.") self.assertIn('isReplacedBy', [rel.type for rel in self.res_generic.metadata.relations.all()], msg="No relation element of type 'isReplacedBy' for the original resource") version_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_generic.short_id) self.assertIn(version_value, [rel.value for rel in self.res_generic.metadata.relations.all()], msg="The new versioned resource identifier is not set as value for " "isReplacedBy for original resource.") # test isReplacedBy is removed after the new versioned resource is deleted hydroshare.delete_resource(new_res_generic.short_id) self.assertNotIn('isReplacedBy', [rel.type for rel in self.res_generic.metadata.relations.all()], msg="isReplacedBy is not removed from the original resource after " "its versioned resource is deleted") # delete the original resource to make sure iRODS files are cleaned up hydroshare.delete_resource(self.res_generic.short_id)
def test_copy_composite_resource(self): """Test that logical file type objects gets copied along with the metadata that each logical file type object contains. Here we are not testing resource level metadata copy as that has been tested in separate unit tests""" self.raster_obj = open(self.temp_raster_file, 'r') files = [UploadedFile(file=self.raster_obj, name='cea.tif')] self.composite_resource = hydroshare.create_resource( resource_type='CompositeResource', owner=self.owner, title='Test Composite Resource', files=files, auto_aggregate=False ) # run the resource post creation signal utils.resource_post_create_actions(resource=self.composite_resource, user=self.owner, metadata=self.composite_resource.metadata) self.assertEqual(self.composite_resource.files.all().count(), 1) res_file = self.composite_resource.files.first() # check that the resource file is not associated with file type self.assertEqual(res_file.has_logical_file, False) # set the tif file to GeoRasterFile type GeoRasterLogicalFile.set_file_type(self.composite_resource, self.owner, res_file.id) # ensure a nonowner who does not have permission to view a resource cannot copy it with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.composite_resource.short_id, self.nonowner, action='copy') # give nonowner view privilege so nonowner can create a new copy of this resource self.owner.uaccess.share_resource_with_user(self.composite_resource, self.nonowner, PrivilegeCodes.VIEW) orig_res_file = self.composite_resource.files.first() orig_geo_raster_lfo = orig_res_file.logical_file # add some key value metadata orig_geo_raster_lfo.metadata.extra_metadata = {'key-1': 'value-1', 'key-2': 'value-2'} # create a copy of the composite resource new_composite_resource = hydroshare.create_empty_resource(self.composite_resource.short_id, self.nonowner, action='copy') new_composite_resource = hydroshare.copy_resource(self.composite_resource, new_composite_resource) # check that there is 2 GeoRasterLogicalFile objects self.assertEqual(GeoRasterLogicalFile.objects.count(), 2) # compare the 2 GeoRasterLogicalFile objects from the original resource and the new one orig_res_file = self.composite_resource.files.first() orig_geo_raster_lfo = orig_res_file.logical_file copy_res_file = new_composite_resource.files.first() copy_geo_raster_lfo = copy_res_file.logical_file # check that we put the 2 files in a new folder (cea) for res_file in self.composite_resource.files.all(): file_path, base_file_name = res_file.full_path, res_file.file_name expected_file_path = "{}/data/contents/cea/{}" expected_file_path = expected_file_path.format(self.composite_resource.root_path, base_file_name) self.assertEqual(file_path, expected_file_path) for res_file in new_composite_resource.files.all(): file_path, base_file_name = res_file.full_path, res_file.file_name expected_file_path = "{}/data/contents/cea/{}" expected_file_path = expected_file_path.format(new_composite_resource.root_path, base_file_name) self.assertEqual(file_path, expected_file_path) # both logical file objects should have 2 resource files self.assertEqual(orig_geo_raster_lfo.files.count(), copy_geo_raster_lfo.files.count()) self.assertEqual(orig_geo_raster_lfo.files.count(), 2) # both logical file objects should have same dataset_name self.assertEqual(orig_geo_raster_lfo.dataset_name, copy_geo_raster_lfo.dataset_name) # both should have same key/value metadata self.assertEqual(orig_geo_raster_lfo.metadata.extra_metadata, copy_geo_raster_lfo.metadata.extra_metadata) # both logical file objects should have same coverage metadata self.assertEqual(orig_geo_raster_lfo.metadata.coverages.count(), copy_geo_raster_lfo.metadata.coverages.count()) self.assertEqual(orig_geo_raster_lfo.metadata.coverages.count(), 1) org_spatial_coverage = orig_geo_raster_lfo.metadata.spatial_coverage copy_spatial_coverage = copy_geo_raster_lfo.metadata.spatial_coverage self.assertEqual(org_spatial_coverage.type, copy_spatial_coverage.type) self.assertEqual(org_spatial_coverage.type, 'box') self.assertEqual(org_spatial_coverage.value['projection'], copy_spatial_coverage.value['projection']) self.assertEqual(org_spatial_coverage.value['units'], copy_spatial_coverage.value['units']) self.assertEqual(org_spatial_coverage.value['northlimit'], copy_spatial_coverage.value['northlimit']) self.assertEqual(org_spatial_coverage.value['eastlimit'], copy_spatial_coverage.value['eastlimit']) self.assertEqual(org_spatial_coverage.value['southlimit'], copy_spatial_coverage.value['southlimit']) self.assertEqual(org_spatial_coverage.value['westlimit'], copy_spatial_coverage.value['westlimit']) # both logical file objects should have same original coverage org_orig_coverage = orig_geo_raster_lfo.metadata.originalCoverage copy_orig_coverage = copy_geo_raster_lfo.metadata.originalCoverage self.assertEqual(org_orig_coverage.value['projection'], copy_orig_coverage.value['projection']) self.assertEqual(org_orig_coverage.value['units'], copy_orig_coverage.value['units']) self.assertEqual(org_orig_coverage.value['northlimit'], copy_orig_coverage.value['northlimit']) self.assertEqual(org_orig_coverage.value['eastlimit'], copy_orig_coverage.value['eastlimit']) self.assertEqual(org_orig_coverage.value['southlimit'], copy_orig_coverage.value['southlimit']) self.assertEqual(org_orig_coverage.value['westlimit'], copy_orig_coverage.value['westlimit']) # both logical file objects should have same cell information metadata orig_cell_info = orig_geo_raster_lfo.metadata.cellInformation copy_cell_info = copy_geo_raster_lfo.metadata.cellInformation self.assertEqual(orig_cell_info.rows, copy_cell_info.rows) self.assertEqual(orig_cell_info.columns, copy_cell_info.columns) self.assertEqual(orig_cell_info.cellSizeXValue, copy_cell_info.cellSizeXValue) self.assertEqual(orig_cell_info.cellSizeYValue, copy_cell_info.cellSizeYValue) self.assertEqual(orig_cell_info.cellDataType, copy_cell_info.cellDataType) # both logical file objects should have same band information metadata self.assertEqual(orig_geo_raster_lfo.metadata.bandInformations.count(), 1) self.assertEqual(orig_geo_raster_lfo.metadata.bandInformations.count(), copy_geo_raster_lfo.metadata.bandInformations.count()) orig_band_info = orig_geo_raster_lfo.metadata.bandInformations.first() copy_band_info = copy_geo_raster_lfo.metadata.bandInformations.first() self.assertEqual(orig_band_info.noDataValue, copy_band_info.noDataValue) self.assertEqual(orig_band_info.maximumValue, copy_band_info.maximumValue) self.assertEqual(orig_band_info.minimumValue, copy_band_info.minimumValue) # make sure to clean up all created resources to clean up iRODS storage if self.composite_resource: self.composite_resource.delete() if new_composite_resource: new_composite_resource.delete()
def test_copy_raster_resource(self): # ensure a nonowner who does not have permission to view a resource cannot copy it with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_raster.short_id, self.nonowner, action='copy') # give nonowner view privilege so nonowner can create a new copy of this resource self.owner.uaccess.share_resource_with_user(self.res_raster, self.nonowner, PrivilegeCodes.VIEW) new_res_raster = hydroshare.create_empty_resource(self.res_raster.short_id, self.nonowner, action='copy') new_res_raster = hydroshare.copy_resource(self.res_raster, new_res_raster) # test the new copied resource has the same resource type as the original resource self.assertTrue(isinstance(new_res_raster, RasterResource)) # test science metadata elements are copied from the original resource to the new copied # resource self.assertTrue(new_res_raster.metadata.title.value == self.res_raster.metadata.title.value) self.assertTrue(new_res_raster.creator == self.nonowner) # test extended metadata elements are copied from the original resource to the new # copied resource self.assertTrue(OriginalCoverage.objects.filter( object_id=new_res_raster.metadata.id).exists()) self.assertEqual(new_res_raster.metadata.originalCoverage.value, self.res_raster.metadata.originalCoverage.value, msg="OriginalCoverage of new copied resource is not equal to " "that of the original resource") self.assertTrue(CellInformation.objects.filter( object_id=new_res_raster.metadata.id).exists()) newcell = new_res_raster.metadata.cellInformation oldcell = self.res_raster.metadata.cellInformation self.assertEqual(newcell.rows, oldcell.rows, msg="Rows of new copied resource is not equal to that of " "the original resource") self.assertEqual(newcell.columns, oldcell.columns, msg="Columns of new copied resource is not equal to that of the " "original resource") self.assertEqual(newcell.cellSizeXValue, oldcell.cellSizeXValue, msg="CellSizeXValue of new copied resource is not equal to " "that of the original resource") self.assertEqual(newcell.cellSizeYValue, oldcell.cellSizeYValue, msg="CellSizeYValue of new copied resource is not equal to " "that of the original resource") self.assertEqual(newcell.cellDataType, oldcell.cellDataType, msg="CellDataType of new copied resource is not equal to " "that of the original resource") self.assertTrue(BandInformation.objects.filter( object_id=new_res_raster.metadata.id).exists()) newband = new_res_raster.metadata.bandInformations.first() oldband = self.res_raster.metadata.bandInformations.first() self.assertEqual(newband.name, oldband.name, msg="Band name of new copied resource is not equal to that of " "the original resource") # test to make sure a new unique identifier has been created for the new copied resource self.assertIsNotNone(new_res_raster.short_id, msg='Unique identifier has not been ' 'created for new copied resource.') self.assertNotEqual(new_res_raster.short_id, self.res_raster.short_id) # test to make sure the new copied resource has 2 content file # since an additional vrt file is created self.assertEqual(new_res_raster.files.all().count(), 2) # test to make sure the new copied resource has the correct identifier self.assertEqual(new_res_raster.metadata.identifiers.all().count(), 1, msg="Number of identifier elements not equal to 1.") self.assertIn('hydroShareIdentifier', [id.name for id in new_res_raster.metadata.identifiers.all()], msg="hydroShareIdentifier name was not found for new copied resource.") id_url = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_raster.short_id) self.assertIn(id_url, [id.url for id in new_res_raster.metadata.identifiers.all()], msg="Identifier url was not found for new copied resource.") # test to make sure the new copied resource is linked with the original resource via # isDerivedFrom Source metadata element self.assertEqual(new_res_raster.metadata.sources.all().count(), 1, msg="New copied resource does not has source element.") derived_from_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), self.res_raster.short_id) self.assertIn(derived_from_value, [src.derived_from for src in new_res_raster.metadata.sources.all()], msg="The original resource identifier is not set in isDerivedFrom Source " "metadata element of the new copied resource") # make sure to clean up resource so that irods storage can be cleaned up if new_res_raster: new_res_raster.delete()
def test_copy_generic_resource(self): # ensure a nonowner who does not have permission to view a resource cannot copy it with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner, action='copy') # ensure resource cannot be copied if the license does not allow derivation by a non-owner with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic_lic_nd.short_id, self.nonowner, action='copy') with self.assertRaises(PermissionDenied): hydroshare.create_empty_resource(self.res_generic_lic_nc_nd.short_id, self.nonowner, action='copy') # add key/value metadata to original resource self.res_generic.extra_metadata = {'variable': 'temp', 'units': 'deg F'} self.res_generic.save() # give nonowner view privilege so nonowner can create a new copy of this resource self.owner.uaccess.share_resource_with_user(self.res_generic, self.nonowner, PrivilegeCodes.VIEW) new_res_generic = hydroshare.create_empty_resource(self.res_generic.short_id, self.nonowner, action='copy') # test to make sure the new copied empty resource has no content files self.assertEqual(new_res_generic.files.all().count(), 0) new_res_generic = hydroshare.copy_resource(self.res_generic, new_res_generic) # test the new copied resource has the same resource type as the original resource self.assertTrue(isinstance(new_res_generic, GenericResource)) # test the new copied resource has the correct content file with correct path copied over self.assertEqual(new_res_generic.files.all().count(), 2) # add each file of resource to list new_res_file_list = [] for f in new_res_generic.files.all(): new_res_file_list.append(f.resource_file.name) for f in self.res_generic.files.all(): ori_res_no_id_file_path = f.resource_file.name[len(self.res_generic.short_id):] new_res_file_path = new_res_generic.short_id + ori_res_no_id_file_path self.assertIn(new_res_file_path, new_res_file_list, msg='resource content path is not created correctly ' 'for new copied resource') # test key/value metadata copied over self.assertEqual(new_res_generic.extra_metadata, self.res_generic.extra_metadata) # test science metadata elements are copied from the original resource to the new copied # resource self.assertEqual(new_res_generic.metadata.title.value, self.res_generic.metadata.title.value, msg='metadata title is not copied over to the new copied resource') self.assertEqual(new_res_generic.creator, self.nonowner, msg='creator is not copied over to the new copied resource') # test to make sure a new unique identifier has been created for the new copied resource self.assertIsNotNone( new_res_generic.short_id, msg='Unique identifier has not been created for new copied resource.') self.assertNotEqual(new_res_generic.short_id, self.res_generic.short_id) # test to make sure the new copied resource has the correct identifier self.assertEqual(new_res_generic.metadata.identifiers.all().count(), 1, msg="Number of identifier elements not equal to 1.") self.assertIn('hydroShareIdentifier', [id.name for id in new_res_generic.metadata.identifiers.all()], msg="hydroShareIdentifier name was not found for new copied resource.") id_url = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), new_res_generic.short_id) self.assertIn(id_url, [id.url for id in new_res_generic.metadata.identifiers.all()], msg="Identifier url was not found for new copied resource.") # test to make sure the new copied resource is linked with the original resource via # isDerivedFrom Source metadata element self.assertGreater(new_res_generic.metadata.sources.all().count(), 0, msg="New copied resource does not has source element.") derived_from_value = '{}/resource/{}'.format(hydroshare.utils.current_site_url(), self.res_generic.short_id) self.assertIn(derived_from_value, [src.derived_from for src in new_res_generic.metadata.sources.all()], msg="The original resource identifier is not set in isDerivedFrom Source " "metadata element of the new copied resource") # make sure to clean up resource so that irods storage can be cleaned up if new_res_generic: new_res_generic.delete()
def create_new_version_resource_task(ori_res_id, username, new_res_id=None): """ Task for creating a new version of a resource Args: ori_res_id: the original resource id that is to be versioned. new_res_id: the new versioned resource id from the original resource. If None, a new resource will be created. username: the requesting user's username Returns: the new versioned resource url as the payload """ try: new_res = None if not new_res_id: new_res = create_empty_resource(ori_res_id, username) new_res_id = new_res.short_id utils.copy_resource_files_and_AVUs(ori_res_id, new_res_id) # copy metadata from source resource to target new-versioned resource except three elements ori_res = utils.get_resource_by_shortkey(ori_res_id) if not new_res: new_res = utils.get_resource_by_shortkey(new_res_id) utils.copy_and_create_metadata(ori_res, new_res) # add or update Relation element to link source and target resources hs_identifier = new_res.metadata.identifiers.all().filter( name="hydroShareIdentifier")[0] ori_res.metadata.create_element('relation', type='isReplacedBy', value=hs_identifier.url) if new_res.metadata.relations.all().filter( type='isVersionOf').exists(): # the original resource is already a versioned resource, and its isVersionOf relation # element is copied over to this new version resource, needs to delete this element so # it can be created to link to its original resource correctly eid = new_res.metadata.relations.all().filter( type='isVersionOf').first().id new_res.metadata.delete_element('relation', eid) hs_identifier = ori_res.metadata.identifiers.all().filter( name="hydroShareIdentifier")[0] new_res.metadata.create_element('relation', type='isVersionOf', value=hs_identifier.url) if ori_res.resource_type.lower() == "collectionresource": # clone contained_res list of original collection and add to new collection # note that new version collection will not contain "deleted resources" new_res.resources = ori_res.resources.all() # create bag for the new resource create_bag(new_res) # since an isReplaceBy relation element is added to original resource, needs to call # resource_modified() for original resource utils.resource_modified(ori_res, by_user=username, overwrite_bag=False) # if everything goes well up to this point, set original resource to be immutable so that # obsoleted resources cannot be modified from REST API ori_res.raccess.immutable = True ori_res.raccess.save() ori_res.save() return new_res.get_absolute_url() except Exception as ex: if new_res: new_res.delete() raise utils.ResourceVersioningException(str(ex)) finally: # release the lock regardless ori_res.locked_time = None ori_res.save()
def test_resource_operations_in_user_zone(self): super(TestUserZoneIRODSFederation, self).assert_federated_irods_available() # test resource creation and "move" option in federated user zone fed_test_file_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_to_be_deleted) res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Test Generic Resource in User Zone', source_names=[fed_test_file_full_path], move=True) self.assertEqual(res.files.all().count(), 1, msg="Number of content files is not equal to 1") fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) user_path = '/{zone}/home/testuser/'.format( zone=settings.HS_USER_IRODS_ZONE) self.assertEqual(res.resource_federation_path, fed_path) # test original file in user test zone is removed after resource creation # since True is used for move when creating the resource file_path_name = user_path + self.file_to_be_deleted self.assertFalse(self.irods_storage.exists(file_path_name)) # test django_irods CopyFiles() with an iRODS resource name being passed in # as input parameter to verify the file gets copied to the pass-in iRODS resource istorage = res.get_irods_storage() src_path = os.path.join(res.root_path, 'data', 'contents', self.file_to_be_deleted) dest_path = file_path_name istorage.copyFiles(src_path, dest_path, settings.HS_IRODS_LOCAL_ZONE_DEF_RES) # assert file did get copied over self.assertTrue(self.irods_storage.exists(file_path_name)) stdout = self.irods_storage.session.run("ils", None, "-l", file_path_name)[0].split() # assert copied file gets written to the iRODS resource being passed into copyFiles() call self.assertEqual(stdout[2], settings.HS_IRODS_LOCAL_ZONE_DEF_RES) # test resource file deletion res.files.all().delete() self.assertEqual(res.files.all().count(), 0, msg="Number of content files is not equal to 0") # test add multiple files and 'copy' option in federated user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) fed_test_file2_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_two) hydroshare.add_resource_files( res.short_id, source_names=[fed_test_file1_full_path, fed_test_file2_full_path], move=False) # test resource has two files self.assertEqual(res.files.all().count(), 2, msg="Number of content files is not equal to 2") file_list = [] for f in res.files.all(): file_list.append(f.storage_path.split('/')[-1]) self.assertTrue( self.file_one in file_list, msg='file 1 has not been added in the resource in user zone') self.assertTrue( self.file_two in file_list, msg='file 2 has not been added in the resource in user zone') # test original two files in user test zone still exist after adding them to the resource # since False is used for move when creating the resource self.assertTrue(self.irods_storage.exists(user_path + self.file_one)) self.assertTrue(self.irods_storage.exists(user_path + self.file_two)) # test resource deletion hydroshare.resource.delete_resource(res.short_id) self.assertEquals(BaseResource.objects.all().count(), 0, msg='Number of resources not equal to 0') # test create new version resource in user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) ori_res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_test_file1_full_path], move=False) # make sure ori_res is created in federated user zone fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(ori_res.resource_federation_path, fed_path) self.assertEqual(ori_res.files.all().count(), 1, msg="Number of content files is not equal to 1") new_res = hydroshare.create_empty_resource(ori_res.short_id, self.user) new_res = hydroshare.create_new_version_resource( ori_res, new_res, self.user) # only need to test file-related attributes # ensure new versioned resource is created in the same federation zone as original resource self.assertEqual(ori_res.resource_federation_path, new_res.resource_federation_path) # ensure new versioned resource has the same number of content files as original resource self.assertEqual(ori_res.files.all().count(), new_res.files.all().count()) # delete resources to clean up hydroshare.resource.delete_resource(new_res.short_id) hydroshare.resource.delete_resource(ori_res.short_id) # test copy resource in user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) ori_res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_test_file1_full_path], move=False) # make sure ori_res is created in federated user zone fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(ori_res.resource_federation_path, fed_path) self.assertEqual(ori_res.files.all().count(), 1, msg="Number of content files is not equal to 1") new_res = hydroshare.create_empty_resource(ori_res.short_id, self.user, action='copy') new_res = hydroshare.copy_resource(ori_res, new_res) # only need to test file-related attributes # ensure new copied resource is created in the same federation zone as original resource self.assertEqual(ori_res.resource_federation_path, new_res.resource_federation_path) # ensure new copied resource has the same number of content files as original resource self.assertEqual(ori_res.files.all().count(), new_res.files.all().count()) # delete resources to clean up hydroshare.resource.delete_resource(new_res.short_id) hydroshare.resource.delete_resource(ori_res.short_id) # test folder operations in user zone fed_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) fed_file2_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_two) fed_file3_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_three) self.res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[ fed_file1_full_path, fed_file2_full_path, fed_file3_full_path ], move=False) # make sure self.res is created in federated user zone fed_path = '/{zone}/home/{user}'.format( zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(self.res.resource_federation_path, fed_path) # resource should has only three files at this point self.assertEqual(self.res.files.all().count(), 3, msg="resource file count didn't match") self.file_name_list = [self.file_one, self.file_two, self.file_three] super(TestUserZoneIRODSFederation, self).resource_file_oprs() # delete resources to clean up hydroshare.resource.delete_resource(self.res.short_id) # test adding files from federated user zone to an empty resource # created in hydroshare zone res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Test Generic Resource in HydroShare Zone') self.assertEqual(res.files.all().count(), 0, msg="Number of content files is not equal to 0") fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) hydroshare.add_resource_files(res.short_id, source_names=[fed_test_file1_full_path], move=False) # test resource has one file self.assertEqual(res.files.all().count(), 1, msg="Number of content files is not equal to 1") file_list = [] for f in res.files.all(): file_list.append(os.path.basename(f.storage_path)) self.assertTrue( self.file_one in file_list, msg='file 1 has not been added in the resource in hydroshare zone') # test original file in user test zone still exist after adding it to the resource # since 'copy' is used for fed_copy_or_move when adding the file to the resource self.assertTrue(self.irods_storage.exists(user_path + self.file_one)) # test replication of this resource to user zone even if the bag_modified AVU for this # resource is wrongly set to False when the bag for this resource does not exist and # need to be recreated res.setAVU('bag_modified', 'false') hydroshare.resource.replicate_resource_bag_to_user_zone( self.user, res.short_id) self.assertTrue(self.irods_storage.exists(user_path + res.short_id + '.zip'), msg='replicated resource bag is not in the user zone') # test resource deletion hydroshare.resource.delete_resource(res.short_id) self.assertEquals(BaseResource.objects.all().count(), 0, msg='Number of resources not equal to 0') # test to make sure original file still exist after resource deletion self.assertTrue(self.irods_storage.exists(user_path + self.file_one))
def test_resource_operations_in_user_zone(self): super(TestUserZoneIRODSFederation, self).assert_federated_irods_available() # test resource creation and "move" option in federated user zone fed_test_file_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_to_be_deleted) res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Test Generic Resource in User Zone', source_names=[fed_test_file_full_path], move=True ) self.assertEqual(res.files.all().count(), 1, msg="Number of content files is not equal to 1") fed_path = '/{zone}/home/{user}'.format(zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) user_path = '/{zone}/home/testuser/'.format(zone=settings.HS_USER_IRODS_ZONE) self.assertEqual(res.resource_federation_path, fed_path) # test original file in user test zone is removed after resource creation # since True is used for move when creating the resource file_path_name = user_path + self.file_to_be_deleted self.assertFalse(self.irods_storage.exists(file_path_name)) # test django_irods CopyFiles() with an iRODS resource name being passed in # as input parameter to verify the file gets copied to the pass-in iRODS resource istorage = res.get_irods_storage() src_path = os.path.join(res.root_path, 'data', 'contents', self.file_to_be_deleted) dest_path = file_path_name istorage.copyFiles(src_path, dest_path, settings.HS_IRODS_LOCAL_ZONE_DEF_RES) # assert file did get copied over self.assertTrue(self.irods_storage.exists(file_path_name)) stdout = self.irods_storage.session.run("ils", None, "-l", file_path_name)[0].split() # assert copied file gets written to the iRODS resource being passed into copyFiles() call self.assertEqual(stdout[2], settings.HS_IRODS_LOCAL_ZONE_DEF_RES) # test resource file deletion res.files.all().delete() self.assertEqual(res.files.all().count(), 0, msg="Number of content files is not equal to 0") # test add multiple files and 'copy' option in federated user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) fed_test_file2_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_two) hydroshare.add_resource_files( res.short_id, source_names=[fed_test_file1_full_path, fed_test_file2_full_path], move=False) # test resource has two files self.assertEqual(res.files.all().count(), 2, msg="Number of content files is not equal to 2") file_list = [] for f in res.files.all(): file_list.append(f.storage_path.split('/')[-1]) self.assertTrue(self.file_one in file_list, msg='file 1 has not been added in the resource in user zone') self.assertTrue(self.file_two in file_list, msg='file 2 has not been added in the resource in user zone') # test original two files in user test zone still exist after adding them to the resource # since False is used for move when creating the resource self.assertTrue(self.irods_storage.exists(user_path + self.file_one)) self.assertTrue(self.irods_storage.exists(user_path + self.file_two)) # test resource deletion hydroshare.resource.delete_resource(res.short_id) self.assertEquals(BaseResource.objects.all().count(), 0, msg='Number of resources not equal to 0') # test create new version resource in user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) ori_res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_test_file1_full_path], move=False ) # make sure ori_res is created in federated user zone fed_path = '/{zone}/home/{user}'.format(zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(ori_res.resource_federation_path, fed_path) self.assertEqual(ori_res.files.all().count(), 1, msg="Number of content files is not equal to 1") new_res = hydroshare.create_empty_resource(ori_res.short_id, self.user) new_res = hydroshare.create_new_version_resource(ori_res, new_res, self.user) # only need to test file-related attributes # ensure new versioned resource is created in the same federation zone as original resource self.assertEqual(ori_res.resource_federation_path, new_res.resource_federation_path) # ensure new versioned resource has the same number of content files as original resource self.assertEqual(ori_res.files.all().count(), new_res.files.all().count()) # delete resources to clean up hydroshare.resource.delete_resource(new_res.short_id) hydroshare.resource.delete_resource(ori_res.short_id) # test copy resource in user zone fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) ori_res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_test_file1_full_path], move=False ) # make sure ori_res is created in federated user zone fed_path = '/{zone}/home/{user}'.format(zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(ori_res.resource_federation_path, fed_path) self.assertEqual(ori_res.files.all().count(), 1, msg="Number of content files is not equal to 1") new_res = hydroshare.create_empty_resource(ori_res.short_id, self.user, action='copy') new_res = hydroshare.copy_resource(ori_res, new_res) # only need to test file-related attributes # ensure new copied resource is created in the same federation zone as original resource self.assertEqual(ori_res.resource_federation_path, new_res.resource_federation_path) # ensure new copied resource has the same number of content files as original resource self.assertEqual(ori_res.files.all().count(), new_res.files.all().count()) # delete resources to clean up hydroshare.resource.delete_resource(new_res.short_id) hydroshare.resource.delete_resource(ori_res.short_id) # test folder operations in user zone fed_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) fed_file2_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_two) fed_file3_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_three) self.res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Original Generic Resource in User Zone', source_names=[fed_file1_full_path, fed_file2_full_path, fed_file3_full_path], move=False ) # make sure self.res is created in federated user zone fed_path = '/{zone}/home/{user}'.format(zone=settings.HS_USER_IRODS_ZONE, user=settings.HS_LOCAL_PROXY_USER_IN_FED_ZONE) self.assertEqual(self.res.resource_federation_path, fed_path) # resource should has only three files at this point self.assertEqual(self.res.files.all().count(), 3, msg="resource file count didn't match") self.file_name_list = [self.file_one, self.file_two, self.file_three] super(TestUserZoneIRODSFederation, self).resource_file_oprs() # delete resources to clean up hydroshare.resource.delete_resource(self.res.short_id) # test adding files from federated user zone to an empty resource # created in hydroshare zone res = hydroshare.resource.create_resource( resource_type='GenericResource', owner=self.user, title='My Test Generic Resource in HydroShare Zone' ) self.assertEqual(res.files.all().count(), 0, msg="Number of content files is not equal to 0") fed_test_file1_full_path = '/{zone}/home/testuser/{fname}'.format( zone=settings.HS_USER_IRODS_ZONE, fname=self.file_one) hydroshare.add_resource_files( res.short_id, source_names=[fed_test_file1_full_path], move=False) # test resource has one file self.assertEqual(res.files.all().count(), 1, msg="Number of content files is not equal to 1") file_list = [] for f in res.files.all(): file_list.append(os.path.basename(f.storage_path)) self.assertTrue(self.file_one in file_list, msg='file 1 has not been added in the resource in hydroshare zone') # test original file in user test zone still exist after adding it to the resource # since 'copy' is used for fed_copy_or_move when adding the file to the resource self.assertTrue(self.irods_storage.exists(user_path + self.file_one)) # test replication of this resource to user zone even if the bag_modified AVU for this # resource is wrongly set to False when the bag for this resource does not exist and # need to be recreated res.setAVU('bag_modified', 'false') hydroshare.resource.replicate_resource_bag_to_user_zone(self.user, res.short_id) self.assertTrue(self.irods_storage.exists(user_path + res.short_id + '.zip'), msg='replicated resource bag is not in the user zone') # test resource deletion hydroshare.resource.delete_resource(res.short_id) self.assertEquals(BaseResource.objects.all().count(), 0, msg='Number of resources not equal to 0') # test to make sure original file still exist after resource deletion self.assertTrue(self.irods_storage.exists(user_path + self.file_one))