def test_unfederated_folder_path_setting(self):
        """ an unfederated file in a subfolder has the proper state after state changes """
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        ResourceFile.create_folder(self.res, 'foo')

        # add one file to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1, folder='foo')

        # resource should has only one file at this point
        self.assertEqual(self.res.files.all().count(), 1,
                         msg="resource file count didn't match")

        # get the handle of the file created above
        resfile = self.res.files.all()[0]

        # determine where that file should live
        shortpath = os.path.join(self.res.short_id, "data",
                                 "contents", "foo", "file1.txt")

        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        self.assertTrue(resfile.path_is_acceptable(shortpath))

        # non-existent files should raise error
        otherpath = os.path.join(self.res.short_id, "data", "contents", "foo", "file2.txt")
        with self.assertRaises(ValidationError):
            resfile.path_is_acceptable(otherpath)

        # try setting to an unqualified name; should qualify it
        resfile.set_storage_path("foo/file1.txt")
        # should match computed path
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to what it is already
        resfile.set_storage_path(shortpath)
        # should match computed path
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to a good path to a non-existent object
        with self.assertRaises(ValidationError):
            resfile.set_storage_path(otherpath)
        # should not change
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # TODO: how to eliminate this particular error.
        # dumbpath = 'x' + shortpath
        # dumbpath = self.res.short_id + "file1.txt"

        # clean up after folder test
        # ResourceFile.remove_folder(self.res, 'foo', self.user)

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)
    def test_set_resource_flag_make_not_shareable(self):
        # here we are testing the set_resource_flag view function to make a resource not shareable

        # test that the resource is  shareable
        self.assertEqual(self.gen_res_one.raccess.shareable, True)

        url_params = {'shortkey': self.gen_res_one.short_id}
        post_data = {'flag': 'make_not_shareable'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request,
                                     shortkey=self.gen_res_one.short_id)
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        flag_messages = get_messages(request)
        err_messages = [m for m in flag_messages if m.tags == 'error']
        self.assertEqual(len(err_messages), 0)
        # check that the resource is not shareable now
        self.gen_res_one.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_one.raccess.shareable, False)
        # clean up
        hydroshare.delete_resource(self.gen_res_one.short_id)
        hydroshare.delete_resource(self.gen_res_two.short_id)
示例#3
0
    def test_share_resource_with_user_bad_requests(self):
        # here we are testing the share_resource_with_user view function with bad requests
        bad_privilege = 'bad'
        url_params = {'shortkey': self.gen_res.short_id, 'privilege': bad_privilege,
                      'user_id': self.user.id}
        url = reverse('share_resource_with_user', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.owner
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        response = share_resource_with_user(request, shortkey=self.gen_res.short_id,
                                            privilege=bad_privilege, user_id=self.user.id)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        response_data = json.loads(response.content)
        self.assertEqual(response_data['status'], 'error')

        url_params = {'shortkey': self.gen_res.short_id, 'privilege': 'view',
                      'user_id': self.user.id}
        url = reverse('share_resource_with_user', kwargs=url_params)
        request = self.factory.post(url, data={})
        # user does not have permission to grant himself access to resource
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        with self.assertRaises(PermissionDenied):
            share_resource_with_user(request, shortkey=self.gen_res.short_id,
                                     privilege='view', user_id=self.user.id)
        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
示例#4
0
    def test_create_resource_with_invalid_file(self):
        # here we are testing the create_resource view function

        self.assertEqual(BaseResource.objects.count(), 0)
        self.assertEqual(ResourceFile.objects.count(), 0)
        # test with bad sqlite file - this file should not be uploaded
        post_data = {
            'resource-type':
            'TimeSeriesResource',
            'title':
            'Test Time Series Resource Creation',
            'irods_federated':
            'true',
            'files': (self.odm2_sqlite_invalid_file_name,
                      open(self.odm2_sqlite_invalid_file))
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'error')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        # that bad sqlite file was not uploaded
        self.assertEqual(ResourceFile.objects.count(), 0)
        hydroshare.delete_resource(res_id)
    def test_set_resource_flag_make_shareable(self):
        # here we are testing the set_resource_flag view function to make a resource shareable

        # test that the resource is  shareable
        self.assertEqual(self.gen_res_one.raccess.shareable, True)
        # set it not shareable
        self.gen_res_one.raccess.shareable = False
        self.gen_res_one.raccess.save()

        url_params = {'shortkey': self.gen_res_one.short_id}
        post_data = {'flag': 'make_shareable'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request, shortkey=self.gen_res_one.short_id)
        response_data = json.loads(response.content)
        self.assertEqual(response_data['status'], 'success')

        # check that the resource is shareable now
        self.gen_res_one.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_one.raccess.shareable, True)
        # clean up
        hydroshare.delete_resource(self.gen_res_one.short_id)
        hydroshare.delete_resource(self.gen_res_two.short_id)
示例#6
0
    def test_file_metadata_on_resource_delete(self):
        # test that when the composite resource is deleted
        # all metadata associated with NetCDFFileType is deleted
        self.netcdf_file_obj = open(self.netcdf_file, 'r')
        self._create_composite_resource()
        res_file = self.composite_resource.files.first()

        # extract metadata from the tif file
        NetCDFLogicalFile.set_file_type(self.composite_resource, res_file.id,
                                        self.user)

        # test that we have one logical file of type NetCDFLogicalFile as a result
        # of metadata extraction
        self.assertEqual(NetCDFLogicalFile.objects.count(), 1)
        self.assertEqual(NetCDFFileMetaData.objects.count(), 1)

        # test that we have the metadata elements

        # there should be 4 Coverage objects - 2 at the resource level and
        # the other 2 at the file type level
        self.assertEqual(Coverage.objects.count(), 4)
        self.assertEqual(OriginalCoverage.objects.count(), 1)
        self.assertEqual(Variable.objects.count(), 5)

        # delete resource
        hydroshare.delete_resource(self.composite_resource.short_id)

        # test that we have no logical file of type NetCDFLogicalFile
        self.assertEqual(NetCDFLogicalFile.objects.count(), 0)
        self.assertEqual(NetCDFFileMetaData.objects.count(), 0)

        # test that all metadata deleted
        self.assertEqual(Coverage.objects.count(), 0)
        self.assertEqual(OriginalCoverage.objects.count(), 0)
        self.assertEqual(Variable.objects.count(), 0)
    def test_create_resource_with_invalid_file(self):
        # here we are testing the create_resource view function

        self.assertEqual(BaseResource.objects.count(), 0)
        self.assertEqual(ResourceFile.objects.count(), 0)
        # test with bad sqlite file - this file should not be uploaded
        post_data = {'resource-type': 'TimeSeriesResource',
                     'title': 'Test Time Series Resource Creation',
                     'irods_federated': 'true',
                     'files': (self.odm2_sqlite_invalid_file_name,
                               open(self.odm2_sqlite_invalid_file))
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'error')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        # that bad sqlite file was not uploaded
        self.assertEqual(ResourceFile.objects.count(), 0)
        hydroshare.delete_resource(res_id)
    def test_share_resource_with_user(self):
        # here we are testing the share_resource_with_user view function

        # test share resource with self.user with view permission

        # test self.user has no view permission
        self.assertNotIn(self.user, self.gen_res.raccess.view_users)
        self._check_share_with_user(privilege='view')
        # test self.user has now view permission
        self.assertIn(self.user, self.gen_res.raccess.view_users)

        # test share resource with self.user with edit permission

        # test self.user has no edit permission
        self.assertNotIn(self.user, self.gen_res.raccess.edit_users)
        self._check_share_with_user(privilege='edit')
        # test self.user has now edit permission
        self.assertIn(self.user, self.gen_res.raccess.edit_users)

        # test share resource with self.user with owner permission

        # test self.user has no owner permission
        self.assertNotIn(self.user, self.gen_res.raccess.owners)
        self._check_share_with_user(privilege='owner')
        # test self.user has now owner permission
        self.assertIn(self.user, self.gen_res.raccess.owners)

        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
    def test_unfederated_folder_path_setting(self):
        """ an unfederated file in a subfolder has the proper state after state changes """
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        ResourceFile.create_folder(self.res, 'foo')

        # add one file to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1, folder='foo')

        # resource should has only one file at this point
        self.assertEqual(self.res.files.all().count(), 1,
                         msg="resource file count didn't match")

        # get the handle of the file created above
        resfile = self.res.files.all()[0]

        # determine where that file should live
        shortpath = os.path.join(self.res.short_id, "data",
                                 "contents", "foo", "file1.txt")

        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        self.assertTrue(resfile.path_is_acceptable(shortpath))

        # non-existent files should raise error
        otherpath = os.path.join(self.res.short_id, "data", "contents", "foo", "file2.txt")
        with self.assertRaises(ValidationError):
            resfile.path_is_acceptable(otherpath)

        # try setting to an unqualified name; should qualify it
        resfile.set_storage_path("foo/file1.txt")
        # should match computed path
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to what it is already
        resfile.set_storage_path(shortpath)
        # should match computed path
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to a good path to a non-existent object
        with self.assertRaises(ValidationError):
            resfile.set_storage_path(otherpath)
        # should not change
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # TODO: how to eliminate this particular error.
        # dumbpath = 'x' + shortpath
        # dumbpath = self.res.short_id + "file1.txt"

        # clean up after folder test
        # ResourceFile.remove_folder(self.res, 'foo', self.user)

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)
示例#10
0
    def test_share_resource_with_user(self):
        # here we are testing the share_resource_with_user view function

        # test share resource with self.user with view permission

        # test self.user has no view permission
        self.assertNotIn(self.user, self.gen_res.raccess.view_users)
        self._check_share_with_user(privilege='view')
        # test self.user has now view permission
        self.assertIn(self.user, self.gen_res.raccess.view_users)

        # test share resource with self.user with edit permission

        # test self.user has no edit permission
        self.assertNotIn(self.user, self.gen_res.raccess.edit_users)
        self._check_share_with_user(privilege='edit')
        # test self.user has now edit permission
        self.assertIn(self.user, self.gen_res.raccess.edit_users)

        # test share resource with self.user with owner permission

        # test self.user has no owner permission
        self.assertNotIn(self.user, self.gen_res.raccess.owners)
        self._check_share_with_user(privilege='owner')
        # test self.user has now owner permission
        self.assertIn(self.user, self.gen_res.raccess.owners)

        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
示例#11
0
    def test_unshare_resource_with_group(self):
        # here we are testing the unshare_resource_with_group view function

        # test unshare resource with self.test_group

        # test self.test_group has no view permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.view_groups)
        # grant view access to self.test_group
        self.owner.uaccess.share_resource_with_group(self.gen_res,
                                                     self.test_group,
                                                     PrivilegeCodes.VIEW)
        # test self.test_group has now view permission
        self.gen_res.raccess.refresh_from_db()
        self.assertIn(self.test_group, self.gen_res.raccess.view_groups)

        self._check_unshare_with_group()
        # test self.test_group has no view permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.view_groups)

        # grant edit access to test_group
        self.owner.uaccess.share_resource_with_group(self.gen_res,
                                                     self.test_group,
                                                     PrivilegeCodes.CHANGE)
        # test test_group has now edit permission
        self.gen_res.raccess.refresh_from_db()
        self.assertIn(self.test_group, self.gen_res.raccess.edit_groups)

        self._check_unshare_with_group()
        # test test_group has no edit permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.edit_groups)

        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
示例#12
0
 def test_01_delete_resource(self):
     """Delete works for resources: privileges are deleted with resource"""
     verdi = self.verdi
     dog = self.dog
     self.assertTrue(dog.uaccess.can_delete_resource(verdi))
     hydroshare.delete_resource(verdi.short_id)
     self.assertFalse(dog.uaccess.can_delete_resource(verdi))
    def test_file_metadata_on_resource_delete(self):
        # test that when the composite resource is deleted
        # all metadata associated with GeoFeatureLogicalFile Type is deleted

        self.create_composite_resource(self.states_required_zip_file)
        res_file = self.composite_resource.files.first()

        # extract metadata from the tif file
        GeoFeatureLogicalFile.set_file_type(self.composite_resource, self.user,
                                            res_file.id)

        # test that we have one logical file of type GeoFeatureLogicalFile as a result
        # of metadata extraction
        self.assertEqual(GeoFeatureLogicalFile.objects.count(), 1)
        self.assertEqual(GeoFeatureFileMetaData.objects.count(), 1)

        # test that we have the metadata elements
        # there should be no Coverage objects
        self.assertEqual(Coverage.objects.count(), 0)
        self.assertEqual(GeometryInformation.objects.count(), 1)
        self.assertEqual(OriginalCoverage.objects.count(), 1)
        self.assertEqual(FieldInformation.objects.count(), 5)

        # delete resource
        hydroshare.delete_resource(self.composite_resource.short_id)

        # test that we have no logical file of type GeoFeatureLogicalFileType
        self.assertEqual(GeoFeatureLogicalFile.objects.count(), 0)
        self.assertEqual(GeoFeatureFileMetaData.objects.count(), 0)

        # test that all metadata deleted
        self.assertEqual(Coverage.objects.count(), 0)
        self.assertEqual(GeometryInformation.objects.count(), 0)
        self.assertEqual(OriginalCoverage.objects.count(), 0)
        self.assertEqual(FieldInformation.objects.count(), 0)
    def test_aggregation_metadata_on_resource_delete(self):
        # test that when the composite resource is deleted
        # all metadata associated with NetCDFLogicalFile Type is deleted

        self.create_composite_resource(self.netcdf_file)
        res_file = self.composite_resource.files.first()

        # extract metadata from the tif file
        NetCDFLogicalFile.set_file_type(self.composite_resource, self.user, res_file.id)

        # test that we have one logical file of type NetCDFLogicalFile as a result
        # of metadata extraction
        self.assertEqual(NetCDFLogicalFile.objects.count(), 1)
        self.assertEqual(NetCDFFileMetaData.objects.count(), 1)

        # test that we have the metadata elements

        # there should be 4 Coverage objects - 2 at the resource level and
        # the other 2 at the file type level
        self.assertEqual(Coverage.objects.count(), 4)
        self.assertEqual(OriginalCoverage.objects.count(), 1)
        self.assertEqual(Variable.objects.count(), 5)

        # delete resource
        hydroshare.delete_resource(self.composite_resource.short_id)

        # test that we have no logical file of type NetCDFLogicalFile
        self.assertEqual(NetCDFLogicalFile.objects.count(), 0)
        self.assertEqual(NetCDFFileMetaData.objects.count(), 0)

        # test that all metadata deleted
        self.assertEqual(Coverage.objects.count(), 0)
        self.assertEqual(OriginalCoverage.objects.count(), 0)
        self.assertEqual(Variable.objects.count(), 0)
示例#15
0
    def test_delete_file(self):
        # here we are testing delete_file view function

        # There should be no files for the resource now
        self.assertEqual(self.gen_res.files.count(), 0)

        # add a file
        post_data = {'files': (self.txt_file_name_1, open(self.txt_file_path_1), 'text/plain')}
        url_params = {'shortkey': self.gen_res.short_id}

        url = reverse('add_files_to_resource', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        add_files_to_resource(request, shortkey=self.gen_res.short_id)
        res_file = self.gen_res.files.first()

        # test the delete_file view function

        url_params = {'shortkey': self.gen_res.short_id, 'f': res_file.id}

        url = reverse('delete_file', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user
        request.META['HTTP_REFERER'] = 'some-url'
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = delete_file(request, shortkey=self.gen_res.short_id, f=res_file.id)
        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
        self.assertEqual(response['Location'], request.META['HTTP_REFERER'])
        self.assertEqual(self.gen_res.files.count(), 0)

        hydroshare.delete_resource(self.gen_res.short_id)
 def test_09_retract(self):
     """Retracted resources cannot be accessed"""
     chewies = self.chewies
     resource_short_id = chewies.short_id
     hydroshare.delete_resource(chewies.short_id)
     with self.assertRaises(Http404):
         hydroshare.get_resource(resource_short_id)
 def test_09_retract(self):
     """Retracted resources cannot be accessed"""
     chewies = self.chewies
     resource_short_id = chewies.short_id
     hydroshare.delete_resource(chewies.short_id)
     with self.assertRaises(Http404):
         hydroshare.get_resource(resource_short_id)
示例#18
0
    def test_create_resource(self):
        # here we are testing the create_resource view function

        # test with no file upload
        post_data = {
            'resource-type': 'CompositeResource',
            'title': 'Test Composite Resource Creation',
            'irods_federated': 'false'
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        hydroshare.delete_resource(res_id)
        self.assertEqual(BaseResource.objects.count(), 0)

        # test with file upload

        # at this point there should not be any resource file
        self.assertEqual(ResourceFile.objects.count(), 0)
        # at this point there should not be any generic logical file
        self.assertEqual(GenericLogicalFile.objects.count(), 0)
        post_data = {
            'resource-type': 'CompositeResource',
            'title': 'Test Composite Resource Creation',
            'irods_federated': 'false',
            'files':
            (self.txt_file_name, open(self.txt_file_path), 'text/plain')
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        # at this point there should 1 resource file
        self.assertEqual(ResourceFile.objects.count(), 1)
        # at this point there should not be any generic logical file as we not more
        # by default making any uploaded file as part of generic logical file
        self.assertEqual(GenericLogicalFile.objects.count(), 0)

        hydroshare.delete_resource(res_id)
示例#19
0
 def delete(self, request, pk):
     # only resource owners are allowed to delete
     view_utils.authorize(
         request, pk, needed_permission=ACTION_TO_AUTHORIZE.DELETE_RESOURCE)
     hydroshare.delete_resource(pk)
     # spec says we need return the id of the resource that got deleted - otherwise would
     # have used status code 204 and not 200
     return Response(data={'resource_id': pk}, status=status.HTTP_200_OK)
示例#20
0
    def test_create_resource(self):
        # here we are testing the create_resource view function

        # test with no file upload
        post_data = {
            'resource-type': 'TimeSeriesResource',
            'title': 'Test Time Series Resource Creation',
            'irods_federated': 'true'
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        hydroshare.delete_resource(res_id)
        self.assertEqual(BaseResource.objects.count(), 0)

        # test with file upload
        self.assertEqual(ResourceFile.objects.count(), 0)
        post_data = {
            'resource-type': 'TimeSeriesResource',
            'title': 'Test Time Series Resource Creation',
            'irods_federated': 'true',
            'files': (self.odm2_sqlite_file_name, open(self.odm2_sqlite_file))
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        self.assertEqual(ResourceFile.objects.count(), 1)
        ts_resource = BaseResource.objects.filter(short_id=res_id).first()
        # check that the resource title got updated due to metadata extraction as part of resource
        # creation
        self.assertEqual(
            ts_resource.metadata.title.value,
            "Water temperature data from the Little Bear River, UT")
        hydroshare.delete_resource(res_id)
    def test_create_resource(self):
        # here we are testing the create_resource view function

        # test with no file upload
        post_data = {'resource-type': 'CompositeResource',
                     'title': 'Test Composite Resource Creation',
                     'irods_federated': 'false'
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        hydroshare.delete_resource(res_id)
        self.assertEqual(BaseResource.objects.count(), 0)

        # test with file upload

        # at this point there should not be any resource file
        self.assertEqual(ResourceFile.objects.count(), 0)
        # at this point there should not be any generic logical file
        self.assertEqual(GenericLogicalFile.objects.count(), 0)
        post_data = {'resource-type': 'CompositeResource',
                     'title': 'Test Composite Resource Creation',
                     'irods_federated': 'false',
                     'files': (self.txt_file_name, open(self.txt_file_path), 'text/plain')
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        # at this point there should 1 resource file
        self.assertEqual(ResourceFile.objects.count(), 1)
        # at this point there should not be any generic logical file as we not more
        # by default making any uploaded file as part of generic logical file
        self.assertEqual(GenericLogicalFile.objects.count(), 0)

        hydroshare.delete_resource(res_id)
示例#22
0
    def test_delete_author(self):
        # testing the delete_author view function
        # add an author element and then delete it

        # the resource should have only the original author now
        self.assertEqual(self.gen_res.metadata.creators.count(), 1)
        url_params = {
            'shortkey': self.gen_res.short_id,
            'element_name': 'creator'
        }
        post_data = {'name': 'Smith, John', 'email': '*****@*****.**'}
        url = reverse('add_metadata_element', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it an ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = add_metadata_element(request,
                                        shortkey=self.gen_res.short_id,
                                        element_name='creator')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_dict = json.loads(response.content.decode())
        self.assertEqual(response_dict['status'], 'success')
        self.assertEqual(response_dict['element_name'], 'creator')
        self.gen_res.refresh_from_db()
        # there should be two authors now
        self.assertEqual(self.gen_res.metadata.creators.count(), 2)

        # delete the author we added above
        author = self.gen_res.metadata.creators.all()[1]
        url_params = {
            'shortkey': self.gen_res.short_id,
            'element_id': author.id
        }

        url = reverse('delete_author', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user

        request.META['HTTP_REFERER'] = 'some-url'
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = delete_author(request,
                                 shortkey=self.gen_res.short_id,
                                 element_id=author.id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.gen_res.refresh_from_db()
        # there should be only the original author now
        self.assertEqual(self.gen_res.metadata.creators.count(), 1)

        hydroshare.delete_resource(self.gen_res.short_id)
示例#23
0
    def test_create_resource(self):
        # here we are testing the create_resource view function

        # test with no file upload
        post_data = {
            'resource-type': 'GenericResource',
            'title': 'Test Generic Resource Creation',
            'irods_federated': 'true'
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        hydroshare.delete_resource(res_id)
        self.assertEqual(BaseResource.objects.count(), 0)

        # test with file upload
        self.assertEqual(ResourceFile.objects.count(), 0)
        post_data = {
            'resource-type': 'GenericResource',
            'title': 'Test Generic Resource Creation',
            'irods_federated': 'true',
            'files':
            (self.txt_file_name, open(self.txt_file_path), 'text/plain')
        }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(
            BaseResource.objects.filter(short_id=res_id).exists(), True)
        self.assertEqual(ResourceFile.objects.count(), 1)
        hydroshare.delete_resource(res_id)
    def test_change_quota_holder(self):
        # here we are testing the change_quota_holder view function
        url_params = {'shortkey': self.res.short_id}
        url = reverse('change_quota_holder', kwargs=url_params)
        request = self.factory.post(url, data={'new_holder_username': '******'})
        request.user = self.user1

        self.add_session_to_request(request)
        response = change_quota_holder(request, shortkey=self.res.short_id)
        self.assertTrue(self.res.get_quota_holder() == self.user2)
        self.assertEqual(response.status_code, status.HTTP_302_FOUND)

        # clean up
        hydroshare.delete_resource(self.res.short_id)
    def test_create_resource(self):
        # here we are testing the create_resource view function

        # test with no file upload
        post_data = {'resource-type': 'TimeSeriesResource',
                     'title': 'Test Time Series Resource Creation',
                     'irods_federated': 'true'
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        hydroshare.delete_resource(res_id)
        self.assertEqual(BaseResource.objects.count(), 0)

        # test with file upload
        self.assertEqual(ResourceFile.objects.count(), 0)
        post_data = {'resource-type': 'TimeSeriesResource',
                     'title': 'Test Time Series Resource Creation',
                     'irods_federated': 'true',
                     'files': (self.odm2_sqlite_file_name, open(self.odm2_sqlite_file))
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        self.assertEqual(ResourceFile.objects.count(), 1)
        ts_resource = BaseResource.objects.filter(short_id=res_id).first()
        # check that the resource title got updated due to metadata extraction as part of resource
        # creation
        self.assertEqual(ts_resource.metadata.title.value,
                         "Water temperature data from the Little Bear River, UT")
        hydroshare.delete_resource(res_id)
示例#26
0
    def test_set_owner(self):
        res = hydroshare.create_resource('GenericResource', self.user, 'res1')
        user2 = hydroshare.create_account('*****@*****.**',
                                          username='******',
                                          first_name='User2_FirstName',
                                          last_name='User2_LastName',
                                          password='******')
        post_data = {'user': user2.pk, 'api_key': self.user.api_key.key}
        url = '{0}{1}/'.format(self.url_base, res.short_id)
        resp = self.api_client.put(url, data=post_data)

        self.assertEqual(resp.body, res.short_id)

        hydroshare.delete_resource(res.short_id)
    def test_change_quota_holder(self):
        # here we are testing the change_quota_holder view function
        url_params = {'shortkey': self.res.short_id}
        url = reverse('change_quota_holder', kwargs=url_params)
        request = self.factory.post(url,
                                    data={'new_holder_username': '******'})
        request.user = self.user1

        self.add_session_to_request(request)
        response = change_quota_holder(request, shortkey=self.res.short_id)
        self.assertTrue(self.res.get_quota_holder() == self.user2)
        self.assertEqual(response.status_code, status.HTTP_302_FOUND)

        # clean up
        hydroshare.delete_resource(self.res.short_id)
    def test_set_resource_flag_make_public(self):
        # here we are testing the set_resource_flag view function to make a resource public

        # test that trying set the resource flag to public  when there is no content file
        # or required metadata it should not change the resource flag

        # test that the resource is not public
        self.assertEqual(self.gen_res_one.raccess.public, False)
        url_params = {'shortkey': self.gen_res_one.short_id}
        post_data = {'flag': 'make_public'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        set_resource_flag(request, shortkey=self.gen_res_one.short_id)
        # check that the resource is still not public
        self.gen_res_one.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_one.raccess.public, False)
        flag_messages = get_messages(request)
        err_messages = [m for m in flag_messages if m.tags == 'error']
        self.assertNotEqual(len(err_messages), 0)

        # setting flag to public for 2nd resource should succeed
        # test that the resource is not public
        self.assertEqual(self.gen_res_two.raccess.public, False)
        url_params = {'shortkey': self.gen_res_two.short_id}
        post_data = {'flag': 'make_public'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request,
                                     shortkey=self.gen_res_two.short_id)
        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
        flag_messages = get_messages(request)
        err_messages = [m for m in flag_messages if m.tags == 'error']
        self.assertEqual(len(err_messages), 0)
        # check that the resource is public now
        self.gen_res_two.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_two.raccess.public, True)

        # clean up
        hydroshare.delete_resource(self.gen_res_one.short_id)
        hydroshare.delete_resource(self.gen_res_two.short_id)
    def test_resource_file_folder_oprs(self):
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        # add the three files to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1, self.test_file_2,
                                      self.test_file_3)

        # resource should has only three files at this point
        self.assertEqual(self.res.files.all().count(), 3,
                         msg="resource file count didn't match")
        super(TestResourceFileFolderOprsAPI, self).resource_file_oprs()

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)
    def test_set_owner(self):
        res = hydroshare.create_resource("GenericResource", self.user, "res1")
        user2 = hydroshare.create_account(
            "*****@*****.**",
            username="******",
            first_name="User2_FirstName",
            last_name="User2_LastName",
            password="******",
        )
        post_data = {"user": user2.pk, "api_key": self.user.api_key.key}
        url = "{0}{1}/".format(self.url_base, res.short_id)
        resp = self.api_client.put(url, data=post_data)

        self.assertEqual(resp.body, res.short_id)

        hydroshare.delete_resource(res.short_id)
示例#31
0
    def test_change_quota_holder(self):
        # here we are testing the change_quota_holder view function
        url_params = {'shortkey': self.res.short_id}
        url = reverse('change_quota_holder', kwargs=url_params)
        request = self.factory.post(url,
                                    data={'new_holder_username': '******'})
        request.user = self.user1

        self.add_session_to_request(request)
        response = change_quota_holder(request, shortkey=self.res.short_id)
        response_data = json.loads(response.content.decode())
        self.assertTrue(self.res.get_quota_holder() == self.user2)
        self.assertEqual(response_data['status'], 'success')

        # clean up
        hydroshare.delete_resource(self.res.short_id)
    def test_replicate_bag(self):
        # here we are testing rep_res_bag_to_irods_user_zone view function
        super(TestReplicateBagToUserZone, self).assert_federated_irods_available()

        url_params = {'shortkey': self.gen_res.short_id}
        url = reverse('replicate_bag_user_zone', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        response = rep_res_bag_to_irods_user_zone(request, shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = json.loads(response.content)
        self.assertIn('success',  response_data)
        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
示例#33
0
    def test_set_resource_flag_make_discoverable(self):
        # here we are testing the set_resource_flag view function to make a resource discoverable

        # test that trying set the resource discoverable when there is no content file
        # or required metadata it should not make the resource discoverable

        # test that the resource is not discoverable
        self.assertEqual(self.gen_res_one.raccess.discoverable, False)
        url_params = {'shortkey': self.gen_res_one.short_id}
        post_data = {'flag': 'make_discoverable'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request,
                                     shortkey=self.gen_res_one.short_id)
        # check that the resource is still not discoverable
        self.gen_res_one.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_one.raccess.discoverable, False)
        response_data = json.loads(response.content.decode())
        self.assertEqual(response_data['status'], 'error')

        # setting flag to discoverable for 2nd resource should succeed
        # test that the resource is not discoverable
        self.assertEqual(self.gen_res_two.raccess.discoverable, False)
        url_params = {'shortkey': self.gen_res_two.short_id}
        post_data = {'flag': 'make_discoverable'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request,
                                     shortkey=self.gen_res_two.short_id)
        response_data = json.loads(response.content.decode())
        self.assertEqual(response_data['status'], 'success')

        # check that the resource is discoverable now
        self.gen_res_two.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_two.raccess.discoverable, True)

        # clean up
        hydroshare.delete_resource(self.gen_res_one.short_id)
        hydroshare.delete_resource(self.gen_res_two.short_id)
    def test_update_key_value_metadata(self):
        # here we are testing the update_key_value_metadata view function

        # no key/value metadata at this point
        self.assertEqual(self.gen_res.extra_metadata, {})

        # create key/value metadata
        url_params = {'shortkey': self.gen_res.short_id}
        post_data = {'key1': 'key-1', 'value1': 'value-1'}
        url = reverse('update_key_value_metadata', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = update_key_value_metadata(request,
                                             shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_dict = json.loads(response.content.decode())
        self.assertEqual(response_dict['status'], 'success')
        self.gen_res.refresh_from_db()
        self.assertEqual(self.gen_res.extra_metadata, post_data)

        # update key/value metadata
        url_params = {'shortkey': self.gen_res.short_id}
        post_data = {
            'key1A': 'key-1A',
            'value1': 'value-1',
            'key1B': 'key-1B',
            'value1B': 'value-1B'
        }
        url = reverse('update_key_value_metadata', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = update_key_value_metadata(request,
                                             shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_dict = json.loads(response.content.decode())
        self.assertEqual(response_dict['status'], 'success')
        self.gen_res.refresh_from_db()
        self.assertEqual(self.gen_res.extra_metadata, post_data)

        hydroshare.delete_resource(self.gen_res.short_id)
    def test_create_resource(self):
        # here we are testing the create_resource view function

        # test with no file upload
        post_data = {'resource-type': 'GenericResource',
                     'title': 'Test Generic Resource Creation',
                     'irods_federated': 'true'
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        hydroshare.delete_resource(res_id)
        self.assertEqual(BaseResource.objects.count(), 0)

        # test with file upload
        self.assertEqual(ResourceFile.objects.count(), 0)
        post_data = {'resource-type': 'GenericResource',
                     'title': 'Test Generic Resource Creation',
                     'irods_federated': 'true',
                     'files': (self.txt_file_name, open(self.txt_file_path), 'text/plain')
                     }
        url = reverse('create_resource')
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)

        response = create_resource(request)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        json_content = json.loads(response.content)
        self.assertEqual(json_content['status'], 'success')
        self.assertEqual(json_content['file_upload_status'], 'success')
        res_id = json_content['resource_url'].split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        self.assertEqual(ResourceFile.objects.count(), 1)
        hydroshare.delete_resource(res_id)
    def test_set_resource_flag_make_public(self):
        # here we are testing the set_resource_flag view function to make a resource public

        # test that trying set the resource flag to public  when there is no content file
        # or required metadata it should not change the resource flag

        # test that the resource is not public
        self.assertEqual(self.gen_res_one.raccess.public, False)
        url_params = {'shortkey': self.gen_res_one.short_id}
        post_data = {'flag': 'make_public'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request, shortkey=self.gen_res_one.short_id)
        # check that the resource is still not public
        self.gen_res_one.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_one.raccess.public, False)
        response_data = json.loads(response.content)
        self.assertEqual(response_data['status'], 'error')

        # setting flag to public for 2nd resource should succeed
        # test that the resource is not public
        self.assertEqual(self.gen_res_two.raccess.public, False)
        url_params = {'shortkey': self.gen_res_two.short_id}
        post_data = {'flag': 'make_public'}
        url = reverse('set_resource_flag', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user

        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = set_resource_flag(request, shortkey=self.gen_res_two.short_id)
        response_data = json.loads(response.content)
        self.assertEqual(response_data['status'], 'success')

        # check that the resource is public now
        self.gen_res_two.raccess.refresh_from_db()
        self.assertEqual(self.gen_res_two.raccess.public, True)

        # clean up
        hydroshare.delete_resource(self.gen_res_one.short_id)
        hydroshare.delete_resource(self.gen_res_two.short_id)
    def test_replicate_bag(self):
        # here we are testing rep_res_bag_to_irods_user_zone view function
        super(TestReplicateBagToUserZone,
              self).assert_federated_irods_available()

        url_params = {'shortkey': self.gen_res.short_id}
        url = reverse('replicate_bag_user_zone', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        response = rep_res_bag_to_irods_user_zone(
            request, shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = json.loads(response.content.decode())
        self.assertIn('resource copy to user zone', response_data.values())
        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
    def test_resource_file_folder_oprs(self):
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(),
                         0,
                         msg="resource file count didn't match")

        # add the three files to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1,
                                      self.test_file_2, self.test_file_3)

        # resource should has only three files at this point
        self.assertEqual(self.res.files.all().count(),
                         3,
                         msg="resource file count didn't match")
        super(TestResourceFileFolderOprsAPI, self).resource_file_oprs()

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)
示例#39
0
    def test_unshare_resource_with_user(self):
        # here we are testing the unshare_resource_with_user view function

        # test unshare resource with self.user

        # test self.user has no view permission
        self.assertNotIn(self.user, self.gen_res.raccess.view_users)
        # grant view access to self.user
        self.owner.uaccess.share_resource_with_user(self.gen_res, self.user,
                                                    PrivilegeCodes.VIEW)
        # test self.user has now view permission
        self.gen_res.raccess.refresh_from_db()
        self.assertIn(self.user, self.gen_res.raccess.view_users)

        self._check_unshare_with_user()
        # test self.user has no view permission
        self.assertNotIn(self.user, self.gen_res.raccess.view_users)

        # grant edit access to self.user
        self.owner.uaccess.share_resource_with_user(self.gen_res, self.user,
                                                    PrivilegeCodes.CHANGE)
        # test self.user has now edit permission
        self.gen_res.raccess.refresh_from_db()
        self.assertIn(self.user, self.gen_res.raccess.edit_users)

        self._check_unshare_with_user()
        # test self.user has no edit permission
        self.assertNotIn(self.user, self.gen_res.raccess.edit_users)

        # grant owner access to self.user
        self.owner.uaccess.share_resource_with_user(self.gen_res, self.user,
                                                    PrivilegeCodes.OWNER)
        # test self.user has now owner permission
        self.gen_res.raccess.refresh_from_db()
        self.assertIn(self.user, self.gen_res.raccess.owners)

        self._check_unshare_with_user()
        # test self.user has no owner permission
        self.assertNotIn(self.user, self.gen_res.raccess.owners)

        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
示例#40
0
    def test_pdf_classification(self):
        """ files with recognized extensions are classified properly """
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        # add one file to the resource
        test_file_handle = open(self.filenames[0], 'r')
        hydroshare.add_resource_files(self.res.short_id, test_file_handle)

        self.assertEqual(self.res.files.all().count(), 1,
                         msg="resource file count didn't match")

        types = get_content_types(self.res)
        self.assertTrue(is_equal_to_as_set(types[0], ['Composite', self.content_types[0]]))

        self.assertTrue(is_equal_to_as_set(types[1], []))  # no left-over extensions

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)
示例#41
0
    def test_add_files(self):
        # here we are testing add_files_to_resource view function

        # There should be no files for the resource now
        self.assertEqual(self.gen_res.files.count(), 0)

        # add a file
        post_data = {'files': (self.txt_file_name_1, open(self.txt_file_path_1), 'text/plain')}
        url_params = {'shortkey': self.gen_res.short_id}

        url = reverse('add_files_to_resource', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = add_files_to_resource(request, shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # there should be 1 file
        self.assertEqual(self.gen_res.files.count(), 1)

        # test adding a file to a deep folder
        res_file = self.gen_res.files.first()
        hydroshare.delete_resource_file(self.gen_res.short_id, res_file.id, self.user)
        # there should be no file
        self.assertEqual(self.gen_res.files.count(), 0)
        post_data = {'files': (self.txt_file_name_1, open(self.txt_file_path_1), 'text/plain'),
                     'file_folder': 'data/contents/foo'}
        url_params = {'shortkey': self.gen_res.short_id}

        url = reverse('add_files_to_resource', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = add_files_to_resource(request, shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # there should be 1 file
        self.assertEqual(self.gen_res.files.count(), 1)
        hydroshare.delete_resource(self.gen_res.short_id)
示例#42
0
    def test_create_resource_version(self):
        # here we are testing the create_new_version_resource view function

        # we should have 1 resource at this point
        self.assertEqual(BaseResource.objects.count(), 1)
        url_params = {'shortkey': self.gen_res.short_id}
        url = reverse('create_resource_version', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user

        self.add_session_to_request(request)
        response = create_new_version_resource(request, shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
        res_id = response.url.split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        # should have 2 resources now
        self.assertEqual(BaseResource.objects.count(), 2)

        # clean up
        hydroshare.delete_resource(res_id)
        hydroshare.delete_resource(self.gen_res.short_id)
示例#43
0
    def test_copy_resource(self):
        # here we are testing the copy_resource view function

        # we should have 1 resource at this point
        self.assertEqual(BaseResource.objects.count(), 1)
        url_params = {'shortkey': self.gen_res.short_id}
        url = reverse('copy_resource', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user

        self.add_session_to_request(request)
        response = copy_resource(request, shortkey=self.gen_res.short_id)
        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
        res_id = response.url.split('/')[2]
        self.assertEqual(BaseResource.objects.filter(short_id=res_id).exists(), True)
        # should have 2 resources now
        self.assertEqual(BaseResource.objects.count(), 2)

        # clean up
        hydroshare.delete_resource(res_id)
        hydroshare.delete_resource(self.gen_res.short_id)
    def test_share_resource_with_group(self):
        # here we are testing the share_resource_with_group view function

        # test share resource with self.test_group with view permission

        # test self.test_group has no view permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.view_groups)
        self._check_share_with_group(privilege='view')
        self.gen_res.raccess.refresh_from_db()
        # test self.test_group has now view permission
        self.assertIn(self.test_group, self.gen_res.raccess.view_groups)

        # test share resource with self.test_group with edit permission

        # test self.test_group has no edit permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.edit_groups)
        self._check_share_with_group(privilege='edit')
        self.gen_res.raccess.refresh_from_db()
        # test self.test_group has now edit permission
        self.assertIn(self.test_group, self.gen_res.raccess.edit_groups)
        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
示例#45
0
    def test_share_resource_with_group(self):
        # here we are testing the share_resource_with_group view function

        # test share resource with self.test_group with view permission

        # test self.test_group has no view permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.view_groups)
        self._check_share_with_group(privilege='view')
        self.gen_res.raccess.refresh_from_db()
        # test self.test_group has now view permission
        self.assertIn(self.test_group, self.gen_res.raccess.view_groups)

        # test share resource with self.test_group with edit permission

        # test self.test_group has no edit permission
        self.assertNotIn(self.test_group, self.gen_res.raccess.edit_groups)
        self._check_share_with_group(privilege='edit')
        self.gen_res.raccess.refresh_from_db()
        # test self.test_group has now edit permission
        self.assertIn(self.test_group, self.gen_res.raccess.edit_groups)
        # clean up
        hydroshare.delete_resource(self.gen_res.short_id)
    def test_metadata_in_user_zone(self):
        super(TestRasterMetaData, self).assert_federated_irods_available()
        # test metadata extraction with resource creation with tif file coming from user zone space
        fed_test_file_full_path = '/{zone}/home/{username}/{fname}'.format(
            zone=settings.HS_USER_IRODS_ZONE, username=self.user.username,
            fname=self.raster_tif_file_name)
        res_upload_files = []
        _, _, metadata, fed_res_path = utils.resource_pre_create_actions(
            resource_type='RasterResource',
            resource_title='My Test Raster Resource',
            page_redirect_url_key=None,
            files=res_upload_files,
            source_names=[fed_test_file_full_path])

        self.resRaster = hydroshare.create_resource(
            'RasterResource',
            self.user,
            'My Test Raster Resource',
            files=res_upload_files,
            source_names=[fed_test_file_full_path],
            fed_res_path=fed_res_path[0] if len(fed_res_path) == 1 else '',
            move=False,
            metadata=metadata)

        # raster file validation and metadata extraction in post resource creation signal handler
        utils.resource_post_create_actions(resource=self.resRaster, user=self.user,
                                           metadata=[])
        super(TestRasterMetaData, self).raster_metadata_extraction()

        # test metadata is deleted after content file is deleted in user zone space
        # there should be 2 content file: tif file and vrt file at this point
        self.assertEqual(self.resRaster.files.all().count(), 2)

        # there should be 2 format elements
        self.assertEqual(self.resRaster.metadata.formats.all().count(), 2)
        self.assertEqual(self.resRaster.metadata.formats.all().filter(
            value='application/vrt').count(), 1)
        self.assertEqual(self.resRaster.metadata.formats.all().filter(
            value='image/tiff').count(), 1)

        # delete content file now
        hydroshare.delete_resource_file(self.resRaster.short_id, self.raster_tif_file_name,
                                        self.user)

        # there should be no content file
        self.assertEqual(self.resRaster.files.all().count(), 0)

        # there should be a title element
        self.assertNotEqual(self.resRaster.metadata.title, None)

        # there should be no abstract element
        self.assertEqual(self.resRaster.metadata.description, None)

        # there should be 1 creator element
        self.assertEqual(self.resRaster.metadata.creators.all().count(), 1)

        # there should be no contributor element
        self.assertEqual(self.resRaster.metadata.contributors.all().count(), 0)

        # there should be no coverage element
        self.assertEqual(self.resRaster.metadata.coverages.all().count(), 0)

        # there should be no format element
        self.assertEqual(self.resRaster.metadata.formats.all().count(), 0)

        # there should be no subject element
        self.assertEqual(self.resRaster.metadata.subjects.all().count(), 0)

        # testing extended metadata elements - there should be no extended metadata elements
        # at this point
        self.assertEqual(self.resRaster.metadata.originalCoverage, None)
        self.assertEqual(self.resRaster.metadata.cellInformation, None)
        self.assertEqual(self.resRaster.metadata.bandInformations.count(), 0)

        # test metadata extraction with a valid tif file being added coming from user zone space
        res_add_files = []

        # now necessary in order to test add_process
        utils.resource_file_add_pre_process(resource=self.resRaster,
                                            files=res_add_files,
                                            user=self.user,
                                            source_names=[fed_test_file_full_path])

        # file validation and metadata extraction happen during post file add signal handler
        utils.resource_file_add_process(resource=self.resRaster,
                                        files=res_add_files,
                                        user=self.user,
                                        source_names=[fed_test_file_full_path])

        super(TestRasterMetaData, self).raster_metadata_extraction()

        # test metadata deletion when deleting a resource in user zone space
        self.assertEqual(CoreMetaData.objects.all().count(), 1)

        # delete resource
        hydroshare.delete_resource(self.resRaster.short_id)

        # resource core metadata is deleted after resource deletion
        self.assertEqual(CoreMetaData.objects.all().count(), 0)

        # test adding file from user zone to existing empty resource in hydroshare zone
        # even there is no file uploaded to resource initially, there are default extended
        # automatically metadata created
        self.resRaster = hydroshare.create_resource(
            resource_type='RasterResource',
            owner=self.user,
            title='My Test Raster Resource'
        )
        # test metadata extraction with a valid tif file being added coming from user zone space
        # file validation and metadata extraction happen during post file add signal handler
        utils.resource_file_add_process(resource=self.resRaster,
                                        files=[],
                                        user=self.user,
                                        source_names=[fed_test_file_full_path])
        super(TestRasterMetaData, self).raster_metadata_extraction()

        # there should be 2 content file: tif file and vrt file at this point
        self.assertEqual(self.resRaster.files.all().count(), 2)
        # delete resource
        hydroshare.delete_resource(self.resRaster.short_id)
        # resource core metadata is deleted after resource deletion
        self.assertEqual(CoreMetaData.objects.all().count(), 0)
示例#47
0
 def delete(self, request, pk):
     # only resource owners are allowed to delete
     view_utils.authorize(request, pk, needed_permission=ACTION_TO_AUTHORIZE.DELETE_RESOURCE)
     hydroshare.delete_resource(pk)
     return Response(status=status.HTTP_204_NO_CONTENT)
示例#48
0
    def delete_resource(self, pk):
        authorize(self.request, pk, edit=True)

        hydroshare.delete_resource(pk)
        return HttpResponse(pk, content_type=None)
示例#49
0
    def test_CRUD_metadata(self):
        # here we are testing the add_metadata_element view function

        # There should be no keywords (subject element) now
        self.assertEqual(self.gen_res.metadata.subjects.count(), 0)

        # add keywords
        url_params = {'shortkey': self.gen_res.short_id, 'element_name': 'subject'}
        post_data = {'value': 'kw-1, kw 2, key word'}
        url = reverse('add_metadata_element', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = add_metadata_element(request, shortkey=self.gen_res.short_id,
                                        element_name='subject')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_dict = json.loads(response.content)
        self.assertEqual(response_dict['status'], 'success')
        self.assertEqual(response_dict['element_name'], 'subject')
        self.gen_res.refresh_from_db()
        self.assertEqual(self.gen_res.metadata.subjects.count(), 3)

        # here we are testing the update_metadata_element view function

        # update title metadata
        self.assertEqual(self.gen_res.metadata.title.value,
                         'Generic Resource Key/Value Metadata Testing')
        title_element = self.gen_res.metadata.title

        url_params = {'shortkey': self.gen_res.short_id, 'element_name': 'title',
                      'element_id': title_element.id}
        post_data = {'value': 'Updated Resource Title'}
        url = reverse('update_metadata_element', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = update_metadata_element(request, shortkey=self.gen_res.short_id,
                                           element_name='title', element_id=title_element.id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_dict = json.loads(response.content)
        self.assertEqual(response_dict['status'], 'success')
        self.gen_res.refresh_from_db()
        self.assertEqual(self.gen_res.metadata.title.value, 'Updated Resource Title')

        # here we are testing the delete_metadata_element view function

        # first create a contributor element and then delete it
        # there should be no contributors now
        self.assertEqual(self.gen_res.metadata.contributors.count(), 0)
        url_params = {'shortkey': self.gen_res.short_id, 'element_name': 'contributor'}
        post_data = {'name': 'John Smith', 'email': '*****@*****.**'}
        url = reverse('add_metadata_element', kwargs=url_params)
        request = self.factory.post(url, data=post_data)
        request.user = self.user
        # make it a ajax request
        request.META['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
        self.set_request_message_attributes(request)
        response = add_metadata_element(request, shortkey=self.gen_res.short_id,
                                        element_name='contributor')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_dict = json.loads(response.content)
        self.assertEqual(response_dict['status'], 'success')
        self.assertEqual(response_dict['element_name'], 'contributor')
        self.gen_res.refresh_from_db()
        # there should be one contributor now
        self.assertEqual(self.gen_res.metadata.contributors.count(), 1)

        # now delete the contributor we created above
        contributor = self.gen_res.metadata.contributors.first()
        url_params = {'shortkey': self.gen_res.short_id, 'element_name': 'contributor',
                      'element_id': contributor.id}

        url = reverse('delete_metadata_element', kwargs=url_params)
        request = self.factory.post(url, data={})
        request.user = self.user

        request.META['HTTP_REFERER'] = 'some-url'
        self.set_request_message_attributes(request)
        self.add_session_to_request(request)
        response = delete_metadata_element(request, shortkey=self.gen_res.short_id,
                                           element_name='contributor', element_id=contributor.id)
        self.assertEqual(response.status_code, status.HTTP_302_FOUND)
        self.assertEqual(response['Location'], request.META['HTTP_REFERER'])
        self.gen_res.refresh_from_db()
        # there should be no contributors
        self.assertEqual(self.gen_res.metadata.contributors.count(), 0)

        hydroshare.delete_resource(self.gen_res.short_id)
示例#50
0
    def test_unfederated_root_path_checks(self):
        """ an unfederated file in the root folder has the proper state after state changes """
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        check_irods_files(self.res, stop_on_error=True)

        # add one file to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1)

        # should succeed without errors
        check_irods_files(self.res, stop_on_error=True)

        # cleaning should not change anything
        check_irods_files(self.res, stop_on_error=True, log_errors=False, return_errors=True,
                          clean_irods=True, clean_django=True, sync_ispublic=True)

        # resource should has only one file at this point
        self.assertEqual(self.res.files.all().count(), 1,
                         msg="resource file count didn't match")

        # get the handle of the file created above
        resfile = self.res.files.all()[0]

        # determine where that file should live
        shortpath = os.path.join(self.res.short_id, "data", "contents", "file1.txt")

        self.assertEqual(resfile.file_folder, None)
        self.assertEqual(resfile.storage_path, shortpath)

        self.assertTrue(resfile.path_is_acceptable(shortpath))

        # now try to intentionally corrupt it
        resfile.set_short_path("fuzz.txt")

        # should raise exception
        with self.assertRaises(ValidationError):
            check_irods_files(self.res, stop_on_error=True)

        # now don't raise exception and read error
        errors, ecount = check_irods_files(self.res, return_errors=True, log_errors=False)

        self.assertTrue(errors[0].endswith(
            'data/contents/fuzz.txt does not exist in iRODS'))
        self.assertTrue(errors[1].endswith(
            'data/contents/file1.txt in iRODs does not exist in Django'))
        self.assertTrue(errors[2].endswith(
            "type is GenericResource, title is 'My Test Resource'"))

        # now try to clean it up
        errors, ecount = check_irods_files(self.res, return_errors=True, log_errors=False,
                                           clean_irods=True, clean_django=True)
        self.assertTrue(errors[0].endswith(
            'data/contents/fuzz.txt does not exist in iRODS (DELETED FROM DJANGO)'))
        self.assertTrue(errors[1].endswith(
            'data/contents/file1.txt in iRODs does not exist in Django (DELETED FROM IRODS)'))
        self.assertTrue(errors[2].endswith(
            "type is GenericResource, title is 'My Test Resource'"))

        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        # now check should succeed
        errors, ecount = check_irods_files(self.res, stop_on_error=True, log_errors=False)
        self.assertEqual(ecount, 0)

        # delete resources to clean up
        hydroshare.delete_resource(self.res.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 tearDown(self):
     User.objects.all().delete()
     hydroshare.delete_resource(self.res.short_id)
示例#53
0
    def test_federated_folder_path_logic(self):
        """ a federated file in a subfolder has the proper state after state changes """

        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        ResourceFile.create_folder(self.res, 'foo')

        # add one file to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1, folder='foo')

        # resource should has only one file at this point
        self.assertEqual(self.res.files.all().count(), 1,
                         msg="resource file count didn't match")

        # get the handle of the file created above
        resfile = self.res.files.all()[0]

        self.assertEqual(resfile.resource_file.name, os.path.join(self.res.short_id,
                                                                  "data", "contents",
                                                                  "foo", "file1.txt"))
        self.assertEqual(resfile.file_folder, "foo")

        # cheat: set a fake federated path to test path logic
        fedpath = "/myzone/home/myuser"
        self.res.resource_federation_path = fedpath
        self.res.save()
        resfile.content_object.refresh_from_db()
        resfile.set_storage_path('foo/file1.txt', test_exists=False)

        # determine where that file should live
        shortpath = os.path.join(fedpath, self.res.short_id, "data",
                                 "contents", "foo", "file1.txt")

        self.assertEqual(shortpath, resfile.storage_path)

        # this should result in an exact path
        resfile.set_storage_path(shortpath, test_exists=False)

        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        self.assertTrue(resfile.path_is_acceptable(shortpath, test_exists=False))

        # non-existent files should raise error
        otherpath = os.path.join(fedpath, self.res.short_id, "data", "contents", "foo", "file2.txt")
        resfile.path_is_acceptable(otherpath, test_exists=False)
        # This won't work because federation path is fake.
        # with self.assertRaises(ValidationError):
        #     resfile.path_is_acceptable(otherpath, test_exists=True)

        # try setting to an unqualified name; should qualify it
        resfile.set_storage_path("foo/file1.txt", test_exists=False)
        # should match computed path
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to what it is already
        resfile.set_storage_path(shortpath, test_exists=False)
        # should match computed path
        self.assertEqual(resfile.file_folder, "foo")
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to a good path to a non-existent object
        resfile.set_storage_path(otherpath, test_exists=False)

        # conclusion: unfederate the resource
        self.res.resource_federation_path = ""
        self.res.save()
        resfile.content_object.refresh_from_db()
        resfile.set_storage_path("foo/file1.txt", test_exists=False)

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)
    def test_metadata_delete_on_resource_delete(self):
        files = [UploadedFile(file=self.text_file_obj, name=self.text_file_obj.name)]
        utils.resource_file_add_pre_process(resource=self.resModelProgram, files=files,
                                            user=self.user, extract_metadata=False)

        utils.resource_file_add_process(resource=self.resModelProgram, files=files,
                                        user=self.user, extract_metadata=False)

        self.resModelProgram.metadata.create_element('Description', abstract="test abstract")
        self.resModelProgram.metadata.create_element('Subject', value="test subject")
        release_date = '2016-10-24T21:05:00.315907+00:00'
        self.resModelProgram.metadata.create_element('MpMetadata',
                                                     modelVersion='5.1.011',
                                                     modelProgramLanguage='Fortran',
                                                     modelOperatingSystem='Windows',
                                                     modelReleaseDate=release_date,
                                                     modelWebsite='http://www.hydroshare.org',
                                                     modelCodeRepository='http://www.github.com',
                                                     modelReleaseNotes='releaseNote.pdf',
                                                     modelDocumentation='manual.pdf',
                                                     modelSoftware='utilities.exe',
                                                     modelEngine='sourceCode.zip')
        self.resModelProgram.metadata.create_element('Contributor', name="user2")

        # before resource delete
        core_metadata_obj = self.resModelProgram.metadata
        self.assertEqual(CoreMetaData.objects.all().count(), 1)
        # there should be Creator metadata objects
        self.assertTrue(Creator.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Contributor metadata objects
        self.assertTrue(Contributor.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Identifier metadata objects
        self.assertTrue(Identifier.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Type metadata objects
        self.assertTrue(Type.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Source metadata objects
        self.assertFalse(Source.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Relation metadata objects
        self.assertFalse(Relation.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Publisher metadata objects
        self.assertFalse(Publisher.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Title metadata objects
        self.assertTrue(Title.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Description (Abstract) metadata objects
        self.assertTrue(Description.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Date metadata objects
        self.assertTrue(Date.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Subject metadata objects
        self.assertTrue(Subject.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Coverage metadata objects
        self.assertFalse(Coverage.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Format metadata objects
        self.assertTrue(Format.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Language metadata objects
        self.assertTrue(Language.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be Rights metadata objects
        self.assertTrue(Rights.objects.filter(object_id=core_metadata_obj.id).exists())

        # resource specific metadata
        # there should be Model Program metadata objects
        self.assertTrue(MpMetadata.objects.filter(object_id=core_metadata_obj.id).exists())

        # delete resource
        hydroshare.delete_resource(self.resModelProgram.short_id)
        self.assertEquals(CoreMetaData.objects.all().count(), 0)

        # there should be no Creator metadata objects
        self.assertFalse(Creator.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Contributor metadata objects
        self.assertFalse(Contributor.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Identifier metadata objects
        self.assertFalse(Identifier.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Type metadata objects
        self.assertFalse(Type.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Source metadata objects
        self.assertFalse(Source.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Relation metadata objects
        self.assertFalse(Relation.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Publisher metadata objects
        self.assertFalse(Publisher.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Title metadata objects
        self.assertFalse(Title.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Description (Abstract) metadata objects
        self.assertFalse(Description.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Date metadata objects
        self.assertFalse(Date.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Subject metadata objects
        self.assertFalse(Subject.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Coverage metadata objects
        self.assertFalse(Coverage.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Format metadata objects
        self.assertFalse(Format.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Language metadata objects
        self.assertFalse(Language.objects.filter(object_id=core_metadata_obj.id).exists())
        # there should be no Rights metadata objects
        self.assertFalse(Rights.objects.filter(object_id=core_metadata_obj.id).exists())

        # resource specific metadata
        # there should be no Model Output metadata objects
        self.assertFalse(MpMetadata.objects.filter(object_id=core_metadata_obj.id).exists())
    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_metadata_delete_on_resource_delete(self):
        # adding a valid raster tif file should generate some core metadata and all extended
        # metadata
        files = [UploadedFile(file=self.raster_tif_file_obj, name=self.raster_tif_file_name)]
        utils.resource_file_add_process(resource=self.resRaster, files=files, user=self.user,
                                        extract_metadata=True)

        # before resource delete
        # resource core metadata
        raster_metadata_obj = self.resRaster.metadata
        self.assertEqual(CoreMetaData.objects.all().count(), 1)
        # there should be Creator metadata objects
        self.assertTrue(Creator.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Contributor metadata objects
        self.assertFalse(Contributor.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Identifier metadata objects
        self.assertTrue(Identifier.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Type metadata objects
        self.assertTrue(Type.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Source metadata objects
        self.assertFalse(Source.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Relation metadata objects
        self.assertFalse(Relation.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Publisher metadata objects
        self.assertFalse(Publisher.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Title metadata objects
        self.assertTrue(Title.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Description (Abstract) metadata objects
        self.assertFalse(Description.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Date metadata objects
        self.assertTrue(Date.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Subject metadata objects
        self.assertFalse(Subject.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Coverage metadata objects
        self.assertTrue(Coverage.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Format metadata objects
        self.assertTrue(Format.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Language metadata objects
        self.assertTrue(Language.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be Rights metadata objects
        self.assertTrue(Rights.objects.filter(object_id=raster_metadata_obj.id).exists())

        # resource specific metadata
        # there should be original coverage metadata objects
        self.assertTrue(OriginalCoverage.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be CellInformation metadata objects
        self.assertTrue(CellInformation.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be BandInformation metadata objects
        self.assertTrue(BandInformation.objects.filter(object_id=raster_metadata_obj.id).exists())

        # delete resource
        hydroshare.delete_resource(self.resRaster.short_id)
        self.assertEqual(CoreMetaData.objects.all().count(), 0)

        # there should be no Creator metadata objects
        self.assertFalse(Creator.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Contributor metadata objects
        self.assertFalse(Contributor.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Identifier metadata objects
        self.assertFalse(Identifier.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Type metadata objects
        self.assertFalse(Type.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Source metadata objects
        self.assertFalse(Source.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Relation metadata objects
        self.assertFalse(Relation.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Publisher metadata objects
        self.assertFalse(Publisher.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Title metadata objects
        self.assertFalse(Title.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Description (Abstract) metadata objects
        self.assertFalse(Description.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Date metadata objects
        self.assertFalse(Date.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Subject metadata objects
        self.assertFalse(Subject.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Coverage metadata objects
        self.assertFalse(Coverage.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Format metadata objects
        self.assertFalse(Format.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Language metadata objects
        self.assertFalse(Language.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be no Rights metadata objects
        self.assertFalse(Rights.objects.filter(object_id=raster_metadata_obj.id).exists())

        # resource specific metadata
        # there should be no original coverage metadata objects
        self.assertFalse(OriginalCoverage.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be CellInformation metadata objects
        self.assertFalse(CellInformation.objects.filter(object_id=raster_metadata_obj.id).exists())
        # there should be bandInformation metadata objects
        self.assertFalse(BandInformation.objects.filter(object_id=raster_metadata_obj.id).exists())
示例#57
0
    def test_federated_root_path_logic(self):
        """ a federated file path in the root folder has the proper state after state changes """
        # resource should not have any files at this point
        self.assertEqual(self.res.files.all().count(), 0,
                         msg="resource file count didn't match")

        # add one file to the resource
        hydroshare.add_resource_files(self.res.short_id, self.test_file_1)

        # resource should has only one file at this point
        self.assertEqual(self.res.files.all().count(), 1,
                         msg="resource file count didn't match")

        # get the handle of the file created above
        resfile = self.res.files.all()[0]

        # cheat: set a fake federated path to test path logic
        oldfedpath = self.res.resource_federation_path
        oldpath = resfile.storage_path

        # intentionally break path logic by setting an unused federation path
        fedpath = "/myzone/home/myuser"
        self.res.resource_federation_path = fedpath
        self.res.save()
        # must load changes into resfile from self.res before setting storage path
        resfile.content_object.refresh_from_db()
        resfile.set_storage_path('file1.txt', test_exists=False)

        self.assertEqual(self.res.resource_federation_path, fedpath)
        self.assertEqual(resfile.storage_path, get_path(resfile, 'file1.txt'))

        # determine where that file should live; THIS IS FAKE
        shortpath = os.path.join(fedpath, self.res.short_id, "data",
                                 "contents", "file1.txt")

        # intentionally break the resource file path
        resfile.set_storage_path(shortpath, test_exists=False)
        self.assertEqual(shortpath, resfile.storage_path)

        self.assertEqual(resfile.file_folder, None)
        self.assertEqual(resfile.storage_path, shortpath)

        self.assertTrue(resfile.path_is_acceptable(shortpath, test_exists=False))

        otherpath = os.path.join(fedpath, self.res.short_id, "data", "contents", "file2.txt")
        resfile.path_is_acceptable(otherpath, test_exists=False)

        # non-existent files should raise error
        # This won't work because federation path is fake
        # with self.assertRaises(ValidationError):
        #     resfile.path_is_acceptable(otherpath, test_exists=True)

        # try setting to an unqualified name; should qualify it
        resfile.set_storage_path("file1.txt", test_exists=False)
        # should match computed path
        self.assertEqual(resfile.file_folder, None)
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to what it is already
        resfile.set_storage_path(shortpath, test_exists=False)
        # should match computed path
        self.assertEqual(resfile.file_folder, None)
        self.assertEqual(resfile.storage_path, shortpath)

        # now try to change that path to a good path to a non-existent object
        resfile.set_storage_path(otherpath, test_exists=False)

        # conclusion: strip off federation path
        self.res.resource_federation_path = oldfedpath
        self.res.save()
        # must load changes into resfile from self.res before setting storage path
        resfile.content_object.refresh_from_db()
        resfile.set_storage_path(oldpath, test_exists=False)

        # delete resources to clean up
        hydroshare.delete_resource(self.res.short_id)