From 313b1fa1760d0e9dfb5886dde7a1647ee8a17372 Mon Sep 17 00:00:00 2001 From: Tres Seaver Date: Tue, 13 Jun 2017 13:11:14 -0400 Subject: [PATCH] Pass 'user_project' if set for Blob API requests (#3495) --- storage/google/cloud/storage/blob.py | 83 +++++++-- storage/tests/unit/test_blob.py | 264 ++++++++++++++++++++++----- 2 files changed, 284 insertions(+), 63 deletions(-) diff --git a/storage/google/cloud/storage/blob.py b/storage/google/cloud/storage/blob.py index 778166df9249..aad2f47295aa 100644 --- a/storage/google/cloud/storage/blob.py +++ b/storage/google/cloud/storage/blob.py @@ -340,10 +340,14 @@ def exists(self, client=None): :returns: True if the blob exists in Cloud Storage. """ client = self._require_client(client) + # We only need the status code (200 or not) so we seek to + # minimize the returned payload. + query_params = {'fields': 'name'} + + if self.user_project is not None: + query_params['userProject'] = self.user_project + try: - # We only need the status code (200 or not) so we seek to - # minimize the returned payload. - query_params = {'fields': 'name'} # We intentionally pass `_target_object=None` since fields=name # would limit the local properties. client._connection.api_request( @@ -403,6 +407,8 @@ def _get_download_url(self): download_url = _DOWNLOAD_URL_TEMPLATE.format(path=self.path) if self.generation is not None: download_url += u'&generation={:d}'.format(self.generation) + if self.user_project is not None: + download_url += u'&userProject={}'.format(self.user_project) return download_url else: return self.media_link @@ -654,6 +660,10 @@ def _do_multipart_upload(self, client, stream, content_type, upload_url = _MULTIPART_URL_TEMPLATE.format( bucket_path=self.bucket.path) + + if self.user_project is not None: + upload_url += '&userProject={}'.format(self.user_project) + upload = MultipartUpload(upload_url, headers=headers) if num_retries is not None: @@ -726,6 +736,10 @@ def _initiate_resumable_upload(self, client, stream, content_type, upload_url = _RESUMABLE_URL_TEMPLATE.format( bucket_path=self.bucket.path) + + if self.user_project is not None: + upload_url += '&userProject={}'.format(self.user_project) + upload = ResumableUpload(upload_url, chunk_size, headers=headers) if num_retries is not None: @@ -1079,9 +1093,16 @@ def get_iam_policy(self, client=None): the ``getIamPolicy`` API request. """ client = self._require_client(client) + + query_params = {} + + if self.user_project is not None: + query_params['userProject'] = self.user_project + info = client._connection.api_request( method='GET', path='%s/iam' % (self.path,), + query_params=query_params, _target_object=None) return Policy.from_api_repr(info) @@ -1104,11 +1125,18 @@ def set_iam_policy(self, policy, client=None): the ``setIamPolicy`` API request. """ client = self._require_client(client) + + query_params = {} + + if self.user_project is not None: + query_params['userProject'] = self.user_project + resource = policy.to_api_repr() resource['resourceId'] = self.path info = client._connection.api_request( method='PUT', path='%s/iam' % (self.path,), + query_params=query_params, data=resource, _target_object=None) return Policy.from_api_repr(info) @@ -1132,12 +1160,17 @@ def test_iam_permissions(self, permissions, client=None): request. """ client = self._require_client(client) - query = {'permissions': permissions} + query_params = {'permissions': permissions} + + if self.user_project is not None: + query_params['userProject'] = self.user_project + path = '%s/iam/testPermissions' % (self.path,) resp = client._connection.api_request( method='GET', path=path, - query_params=query) + query_params=query_params) + return resp.get('permissions', []) def make_public(self, client=None): @@ -1167,13 +1200,22 @@ def compose(self, sources, client=None): """ if self.content_type is None: raise ValueError("Destination 'content_type' not set.") + client = self._require_client(client) + query_params = {} + + if self.user_project is not None: + query_params['userProject'] = self.user_project + request = { 'sourceObjects': [{'name': source.name} for source in sources], 'destination': self._properties.copy(), } api_response = client._connection.api_request( - method='POST', path=self.path + '/compose', data=request, + method='POST', + path=self.path + '/compose', + query_params=query_params, + data=request, _target_object=self) self._set_properties(api_response) @@ -1205,14 +1247,20 @@ def rewrite(self, source, token=None, client=None): headers.update(_get_encryption_headers( source._encryption_key, source=True)) + query_params = {} + if token: - query_params = {'rewriteToken': token} - else: - query_params = {} + query_params['rewriteToken'] = token + + if self.user_project is not None: + query_params['userProject'] = self.user_project api_response = client._connection.api_request( - method='POST', path=source.path + '/rewriteTo' + self.path, - query_params=query_params, data=self._properties, headers=headers, + method='POST', + path=source.path + '/rewriteTo' + self.path, + query_params=query_params, + data=self._properties, + headers=headers, _target_object=self) rewritten = int(api_response['totalBytesRewritten']) size = int(api_response['objectSize']) @@ -1243,13 +1291,22 @@ def update_storage_class(self, new_class, client=None): raise ValueError("Invalid storage class: %s" % (new_class,)) client = self._require_client(client) + + query_params = {} + + if self.user_project is not None: + query_params['userProject'] = self.user_project + headers = _get_encryption_headers(self._encryption_key) headers.update(_get_encryption_headers( self._encryption_key, source=True)) api_response = client._connection.api_request( - method='POST', path=self.path + '/rewriteTo' + self.path, - data={'storageClass': new_class}, headers=headers, + method='POST', + path=self.path + '/rewriteTo' + self.path, + query_params=query_params, + data={'storageClass': new_class}, + headers=headers, _target_object=self) self._set_properties(api_response['resource']) diff --git a/storage/tests/unit/test_blob.py b/storage/tests/unit/test_blob.py index 084745ebb54d..1c31e9ea1b0f 100644 --- a/storage/tests/unit/test_blob.py +++ b/storage/tests/unit/test_blob.py @@ -317,16 +317,31 @@ def test_exists_miss(self): bucket = _Bucket(client) blob = self._make_one(NONESUCH, bucket=bucket) self.assertFalse(blob.exists()) + self.assertEqual(len(connection._requested), 1) + self.assertEqual(connection._requested[0], { + 'method': 'GET', + 'path': '/b/name/o/{}'.format(NONESUCH), + 'query_params': {'fields': 'name'}, + '_target_object': None, + }) - def test_exists_hit(self): + def test_exists_hit_w_user_project(self): BLOB_NAME = 'blob-name' + USER_PROJECT = 'user-project-123' found_response = ({'status': http_client.OK}, b'') connection = _Connection(found_response) client = _Client(connection) - bucket = _Bucket(client) + bucket = _Bucket(client, user_project=USER_PROJECT) blob = self._make_one(BLOB_NAME, bucket=bucket) bucket._blobs[BLOB_NAME] = 1 self.assertTrue(blob.exists()) + self.assertEqual(len(connection._requested), 1) + self.assertEqual(connection._requested[0], { + 'method': 'GET', + 'path': '/b/name/o/{}'.format(BLOB_NAME), + 'query_params': {'fields': 'name', 'userProject': USER_PROJECT}, + '_target_object': None, + }) def test_delete(self): BLOB_NAME = 'blob-name' @@ -362,7 +377,7 @@ def test__get_download_url_with_media_link(self): def test__get_download_url_on_the_fly(self): blob_name = 'bzzz-fly.txt' - bucket = mock.Mock(path='/b/buhkit', spec=['path']) + bucket = _Bucket(name='buhkit') blob = self._make_one(blob_name, bucket=bucket) self.assertIsNone(blob.media_link) @@ -374,7 +389,7 @@ def test__get_download_url_on_the_fly(self): def test__get_download_url_on_the_fly_with_generation(self): blob_name = 'pretend.txt' - bucket = mock.Mock(path='/b/fictional', spec=['path']) + bucket = _Bucket(name='fictional') blob = self._make_one(blob_name, bucket=bucket) generation = 1493058489532987 # Set the media link on the blob @@ -387,6 +402,20 @@ def test__get_download_url_on_the_fly_with_generation(self): 'fictional/o/pretend.txt?alt=media&generation=1493058489532987') self.assertEqual(download_url, expected_url) + def test__get_download_url_on_the_fly_with_user_project(self): + blob_name = 'pretend.txt' + user_project = 'user-project-123' + bucket = _Bucket(name='fictional', user_project=user_project) + blob = self._make_one(blob_name, bucket=bucket) + + self.assertIsNone(blob.media_link) + download_url = blob._get_download_url() + expected_url = ( + 'https://www.googleapis.com/download/storage/v1/b/' + 'fictional/o/pretend.txt?alt=media&userProject={}'.format( + user_project)) + self.assertEqual(download_url, expected_url) + @staticmethod def _mock_requests_response(status_code, headers, content=b''): return mock.Mock( @@ -778,8 +807,8 @@ def _mock_transport(self, status_code, headers, content=b''): return fake_transport def _do_multipart_success(self, mock_get_boundary, size=None, - num_retries=None): - bucket = mock.Mock(path='/b/w00t', spec=[u'path']) + num_retries=None, user_project=None): + bucket = _Bucket(name='w00t', user_project=user_project) blob = self._make_one(u'blob-name', bucket=bucket) self.assertIsNone(blob.chunk_size) @@ -811,6 +840,8 @@ def _do_multipart_success(self, mock_get_boundary, size=None, 'https://www.googleapis.com/upload/storage/v1' + bucket.path + '/o?uploadType=multipart') + if user_project is not None: + upload_url += '&userProject={}'.format(user_project) payload = ( b'--==0==\r\n' + b'content-type: application/json; charset=UTF-8\r\n\r\n' + @@ -833,6 +864,13 @@ def test__do_multipart_upload_no_size(self, mock_get_boundary): def test__do_multipart_upload_with_size(self, mock_get_boundary): self._do_multipart_success(mock_get_boundary, size=10) + @mock.patch(u'google.resumable_media._upload.get_boundary', + return_value=b'==0==') + def test__do_multipart_upload_with_user_project(self, mock_get_boundary): + user_project = 'user-project-123' + self._do_multipart_success( + mock_get_boundary, user_project=user_project) + @mock.patch(u'google.resumable_media._upload.get_boundary', return_value=b'==0==') def test__do_multipart_upload_with_retry(self, mock_get_boundary): @@ -854,11 +892,12 @@ def test__do_multipart_upload_bad_size(self): 'was specified but the file-like object only had', exc_contents) self.assertEqual(stream.tell(), len(data)) - def _initiate_resumable_helper(self, size=None, extra_headers=None, - chunk_size=None, num_retries=None): + def _initiate_resumable_helper( + self, size=None, extra_headers=None, chunk_size=None, + num_retries=None, user_project=None): from google.resumable_media.requests import ResumableUpload - bucket = mock.Mock(path='/b/whammy', spec=[u'path']) + bucket = _Bucket(name='whammy', user_project=user_project) blob = self._make_one(u'blob-name', bucket=bucket) blob.metadata = {'rook': 'takes knight'} blob.chunk_size = 3 * blob._CHUNK_SIZE_MULTIPLE @@ -892,6 +931,8 @@ def _initiate_resumable_helper(self, size=None, extra_headers=None, 'https://www.googleapis.com/upload/storage/v1' + bucket.path + '/o?uploadType=resumable') + if user_project is not None: + upload_url += '&userProject={}'.format(user_project) self.assertEqual(upload.upload_url, upload_url) if extra_headers is None: self.assertEqual(upload._headers, {}) @@ -944,6 +985,10 @@ def test__initiate_resumable_upload_no_size(self): def test__initiate_resumable_upload_with_size(self): self._initiate_resumable_helper(size=10000) + def test__initiate_resumable_upload_with_user_project(self): + user_project = 'user-project-123' + self._initiate_resumable_helper(user_project=user_project) + def test__initiate_resumable_upload_with_chunk_size(self): one_mb = 1048576 self._initiate_resumable_helper(chunk_size=one_mb) @@ -1023,7 +1068,7 @@ def _do_resumable_upload_call2(blob, content_type, data, 'PUT', resumable_url, data=payload, headers=expected_headers) def _do_resumable_helper(self, use_size=False, num_retries=None): - bucket = mock.Mock(path='/b/yesterday', spec=[u'path']) + bucket = _Bucket(name='yesterday') blob = self._make_one(u'blob-name', bucket=bucket) blob.chunk_size = blob._CHUNK_SIZE_MULTIPLE self.assertIsNotNone(blob.chunk_size) @@ -1266,7 +1311,7 @@ def test_upload_from_string_w_text(self): def _create_resumable_upload_session_helper(self, origin=None, side_effect=None): - bucket = mock.Mock(path='/b/alex-trebek', spec=[u'path']) + bucket = _Bucket(name='alex-trebek') blob = self._make_one('blob-name', bucket=bucket) chunk_size = 99 * blob._CHUNK_SIZE_MULTIPLE blob.chunk_size = chunk_size @@ -1377,8 +1422,49 @@ def test_get_iam_policy(self): kw = connection._requested self.assertEqual(len(kw), 1) - self.assertEqual(kw[0]['method'], 'GET') - self.assertEqual(kw[0]['path'], '%s/iam' % (PATH,)) + self.assertEqual(kw[0], { + 'method': 'GET', + 'path': '%s/iam' % (PATH,), + 'query_params': {}, + '_target_object': None, + }) + + def test_get_iam_policy_w_user_project(self): + from google.cloud.iam import Policy + + BLOB_NAME = 'blob-name' + USER_PROJECT = 'user-project-123' + PATH = '/b/name/o/%s' % (BLOB_NAME,) + ETAG = 'DEADBEEF' + VERSION = 17 + RETURNED = { + 'resourceId': PATH, + 'etag': ETAG, + 'version': VERSION, + 'bindings': [], + } + after = ({'status': http_client.OK}, RETURNED) + EXPECTED = {} + connection = _Connection(after) + client = _Client(connection) + bucket = _Bucket(client=client, user_project=USER_PROJECT) + blob = self._make_one(BLOB_NAME, bucket=bucket) + + policy = blob.get_iam_policy() + + self.assertIsInstance(policy, Policy) + self.assertEqual(policy.etag, RETURNED['etag']) + self.assertEqual(policy.version, RETURNED['version']) + self.assertEqual(dict(policy), EXPECTED) + + kw = connection._requested + self.assertEqual(len(kw), 1) + self.assertEqual(kw[0], { + 'method': 'GET', + 'path': '%s/iam' % (PATH,), + 'query_params': {'userProject': USER_PROJECT}, + '_target_object': None, + }) def test_set_iam_policy(self): import operator @@ -1427,6 +1513,7 @@ def test_set_iam_policy(self): self.assertEqual(len(kw), 1) self.assertEqual(kw[0]['method'], 'PUT') self.assertEqual(kw[0]['path'], '%s/iam' % (PATH,)) + self.assertEqual(kw[0]['query_params'], {}) sent = kw[0]['data'] self.assertEqual(sent['resourceId'], PATH) self.assertEqual(len(sent['bindings']), len(BINDINGS)) @@ -1438,6 +1525,41 @@ def test_set_iam_policy(self): self.assertEqual( sorted(found['members']), sorted(expected['members'])) + def test_set_iam_policy_w_user_project(self): + from google.cloud.iam import Policy + + BLOB_NAME = 'blob-name' + USER_PROJECT = 'user-project-123' + PATH = '/b/name/o/%s' % (BLOB_NAME,) + ETAG = 'DEADBEEF' + VERSION = 17 + BINDINGS = [] + RETURNED = { + 'etag': ETAG, + 'version': VERSION, + 'bindings': BINDINGS, + } + after = ({'status': http_client.OK}, RETURNED) + policy = Policy() + + connection = _Connection(after) + client = _Client(connection) + bucket = _Bucket(client=client, user_project=USER_PROJECT) + blob = self._make_one(BLOB_NAME, bucket=bucket) + + returned = blob.set_iam_policy(policy) + + self.assertEqual(returned.etag, ETAG) + self.assertEqual(returned.version, VERSION) + self.assertEqual(dict(returned), dict(policy)) + + kw = connection._requested + self.assertEqual(len(kw), 1) + self.assertEqual(kw[0]['method'], 'PUT') + self.assertEqual(kw[0]['path'], '%s/iam' % (PATH,)) + self.assertEqual(kw[0]['query_params'], {'userProject': USER_PROJECT}) + self.assertEqual(kw[0]['data'], {'resourceId': PATH}) + def test_test_iam_permissions(self): from google.cloud.storage.iam import STORAGE_OBJECTS_LIST from google.cloud.storage.iam import STORAGE_BUCKETS_GET @@ -1468,6 +1590,39 @@ def test_test_iam_permissions(self): self.assertEqual(kw[0]['path'], '%s/iam/testPermissions' % (PATH,)) self.assertEqual(kw[0]['query_params'], {'permissions': PERMISSIONS}) + def test_test_iam_permissions_w_user_project(self): + from google.cloud.storage.iam import STORAGE_OBJECTS_LIST + from google.cloud.storage.iam import STORAGE_BUCKETS_GET + from google.cloud.storage.iam import STORAGE_BUCKETS_UPDATE + + BLOB_NAME = 'blob-name' + USER_PROJECT = 'user-project-123' + PATH = '/b/name/o/%s' % (BLOB_NAME,) + PERMISSIONS = [ + STORAGE_OBJECTS_LIST, + STORAGE_BUCKETS_GET, + STORAGE_BUCKETS_UPDATE, + ] + ALLOWED = PERMISSIONS[1:] + RETURNED = {'permissions': ALLOWED} + after = ({'status': http_client.OK}, RETURNED) + connection = _Connection(after) + client = _Client(connection) + bucket = _Bucket(client=client, user_project=USER_PROJECT) + blob = self._make_one(BLOB_NAME, bucket=bucket) + + allowed = blob.test_iam_permissions(PERMISSIONS) + + self.assertEqual(allowed, ALLOWED) + + kw = connection._requested + self.assertEqual(len(kw), 1) + self.assertEqual(kw[0]['method'], 'GET') + self.assertEqual(kw[0]['path'], '%s/iam/testPermissions' % (PATH,)) + self.assertEqual( + kw[0]['query_params'], + {'permissions': PERMISSIONS, 'userProject': USER_PROJECT}) + def test_make_public(self): from google.cloud.storage.acl import _ACLEntity @@ -1502,17 +1657,18 @@ def test_compose_wo_content_type_set(self): with self.assertRaises(ValueError): destination.compose(sources=[source_1, source_2]) - def test_compose_minimal(self): + def test_compose_minimal_w_user_project(self): SOURCE_1 = 'source-1' SOURCE_2 = 'source-2' DESTINATION = 'destinaton' RESOURCE = { 'etag': 'DEADBEEF' } + USER_PROJECT = 'user-project-123' after = ({'status': http_client.OK}, RESOURCE) connection = _Connection(after) client = _Client(connection) - bucket = _Bucket(client=client) + bucket = _Bucket(client=client, user_project=USER_PROJECT) source_1 = self._make_one(SOURCE_1, bucket=bucket) source_2 = self._make_one(SOURCE_2, bucket=bucket) destination = self._make_one(DESTINATION, bucket=bucket) @@ -1522,20 +1678,23 @@ def test_compose_minimal(self): self.assertEqual(destination.etag, 'DEADBEEF') - SENT = { - 'sourceObjects': [ - {'name': source_1.name}, - {'name': source_2.name}, - ], - 'destination': { - 'contentType': 'text/plain', - }, - } kw = connection._requested self.assertEqual(len(kw), 1) - self.assertEqual(kw[0]['method'], 'POST') - self.assertEqual(kw[0]['path'], '/b/name/o/%s/compose' % DESTINATION) - self.assertEqual(kw[0]['data'], SENT) + self.assertEqual(kw[0], { + 'method': 'POST', + 'path': '/b/name/o/%s/compose' % DESTINATION, + 'query_params': {'userProject': USER_PROJECT}, + 'data': { + 'sourceObjects': [ + {'name': source_1.name}, + {'name': source_2.name}, + ], + 'destination': { + 'contentType': 'text/plain', + }, + }, + '_target_object': destination, + }) def test_compose_w_additional_property_changes(self): SOURCE_1 = 'source-1' @@ -1559,24 +1718,27 @@ def test_compose_w_additional_property_changes(self): self.assertEqual(destination.etag, 'DEADBEEF') - SENT = { - 'sourceObjects': [ - {'name': source_1.name}, - {'name': source_2.name}, - ], - 'destination': { - 'contentType': 'text/plain', - 'contentLanguage': 'en-US', - 'metadata': { - 'my-key': 'my-value', - } - }, - } kw = connection._requested self.assertEqual(len(kw), 1) - self.assertEqual(kw[0]['method'], 'POST') - self.assertEqual(kw[0]['path'], '/b/name/o/%s/compose' % DESTINATION) - self.assertEqual(kw[0]['data'], SENT) + self.assertEqual(kw[0], { + 'method': 'POST', + 'path': '/b/name/o/%s/compose' % DESTINATION, + 'query_params': {}, + 'data': { + 'sourceObjects': [ + {'name': source_1.name}, + {'name': source_2.name}, + ], + 'destination': { + 'contentType': 'text/plain', + 'contentLanguage': 'en-US', + 'metadata': { + 'my-key': 'my-value', + } + }, + }, + '_target_object': destination, + }) def test_rewrite_response_without_resource(self): SOURCE_BLOB = 'source' @@ -1648,7 +1810,7 @@ def test_rewrite_other_bucket_other_name_no_encryption_partial(self): self.assertNotIn('X-Goog-Encryption-Key', headers) self.assertNotIn('X-Goog-Encryption-Key-Sha256', headers) - def test_rewrite_same_name_no_old_key_new_key_done(self): + def test_rewrite_same_name_no_old_key_new_key_done_w_user_project(self): import base64 import hashlib @@ -1657,6 +1819,7 @@ def test_rewrite_same_name_no_old_key_new_key_done(self): KEY_HASH = hashlib.sha256(KEY).digest() KEY_HASH_B64 = base64.b64encode(KEY_HASH).rstrip().decode('ascii') BLOB_NAME = 'blob' + USER_PROJECT = 'user-project-123' RESPONSE = { 'totalBytesRewritten': 42, 'objectSize': 42, @@ -1666,7 +1829,7 @@ def test_rewrite_same_name_no_old_key_new_key_done(self): response = ({'status': http_client.OK}, RESPONSE) connection = _Connection(response) client = _Client(connection) - bucket = _Bucket(client=client) + bucket = _Bucket(client=client, user_project=USER_PROJECT) plain = self._make_one(BLOB_NAME, bucket=bucket) encrypted = self._make_one(BLOB_NAME, bucket=bucket, encryption_key=KEY) @@ -1682,7 +1845,7 @@ def test_rewrite_same_name_no_old_key_new_key_done(self): self.assertEqual(kw[0]['method'], 'POST') PATH = '/b/name/o/%s/rewriteTo/b/name/o/%s' % (BLOB_NAME, BLOB_NAME) self.assertEqual(kw[0]['path'], PATH) - self.assertEqual(kw[0]['query_params'], {}) + self.assertEqual(kw[0]['query_params'], {'userProject': USER_PROJECT}) SENT = {} self.assertEqual(kw[0]['data'], SENT) @@ -1785,7 +1948,7 @@ def test_update_storage_class_wo_encryption_key(self): self.assertEqual(kw[0]['method'], 'POST') PATH = '/b/name/o/%s/rewriteTo/b/name/o/%s' % (BLOB_NAME, BLOB_NAME) self.assertEqual(kw[0]['path'], PATH) - self.assertNotIn('query_params', kw[0]) + self.assertEqual(kw[0]['query_params'], {}) SENT = {'storageClass': STORAGE_CLASS} self.assertEqual(kw[0]['data'], SENT) @@ -1799,7 +1962,7 @@ def test_update_storage_class_wo_encryption_key(self): self.assertNotIn('X-Goog-Encryption-Key', headers) self.assertNotIn('X-Goog-Encryption-Key-Sha256', headers) - def test_update_storage_class_w_encryption_key(self): + def test_update_storage_class_w_encryption_key_w_user_project(self): import base64 import hashlib @@ -1810,13 +1973,14 @@ def test_update_storage_class_w_encryption_key(self): BLOB_KEY_HASH_B64 = base64.b64encode( BLOB_KEY_HASH).rstrip().decode('ascii') STORAGE_CLASS = u'NEARLINE' + USER_PROJECT = 'user-project-123' RESPONSE = { 'resource': {'storageClass': STORAGE_CLASS}, } response = ({'status': http_client.OK}, RESPONSE) connection = _Connection(response) client = _Client(connection) - bucket = _Bucket(client=client) + bucket = _Bucket(client=client, user_project=USER_PROJECT) blob = self._make_one( BLOB_NAME, bucket=bucket, encryption_key=BLOB_KEY) @@ -1829,7 +1993,7 @@ def test_update_storage_class_w_encryption_key(self): self.assertEqual(kw[0]['method'], 'POST') PATH = '/b/name/o/%s/rewriteTo/b/name/o/%s' % (BLOB_NAME, BLOB_NAME) self.assertEqual(kw[0]['path'], PATH) - self.assertNotIn('query_params', kw[0]) + self.assertEqual(kw[0]['query_params'], {'userProject': USER_PROJECT}) SENT = {'storageClass': STORAGE_CLASS} self.assertEqual(kw[0]['data'], SENT)