def test_versioning(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 version of collection
new_collection = create_empty_resource(self.resCollection.short_id, self.user1)
new_collection = create_new_version_resource(self.resCollection, new_collection, self.user1)
# test the new version is a collection
self.assertTrue(isinstance(new_collection, CollectionResource))
# new version 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 version collection should not affect new version collection
self.resCollection.resources.clear()
self.assertEqual(self.resCollection.resources.count(), 0)
self.assertEqual(new_collection.resources.count(), 3)
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_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):
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))