diff --git a/storage/google/cloud/storage/_helpers.py b/storage/google/cloud/storage/_helpers.py
index 9e47c10269fcb..88f9b8dc0ca7e 100644
--- a/storage/google/cloud/storage/_helpers.py
+++ b/storage/google/cloud/storage/_helpers.py
@@ -67,11 +67,6 @@ def client(self):
         """Abstract getter for the object client."""
         raise NotImplementedError
 
-    @property
-    def user_project(self):
-        """Abstract getter for the object user_project."""
-        raise NotImplementedError
-
     def _require_client(self, client):
         """Check client or verify over-ride.
 
@@ -99,8 +94,6 @@ def reload(self, client=None):
         # Pass only '?projection=noAcl' here because 'acl' and related
         # are handled via custom endpoints.
         query_params = {'projection': 'noAcl'}
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
         api_response = client._connection.api_request(
             method='GET', path=self.path, query_params=query_params,
             _target_object=self)
@@ -147,14 +140,11 @@ def patch(self, client=None):
         client = self._require_client(client)
         # Pass '?projection=full' here because 'PATCH' documented not
         # to work properly w/ 'noAcl'.
-        query_params = {'projection': 'full'}
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
         update_properties = {key: self._properties[key]
                              for key in self._changes}
         api_response = client._connection.api_request(
             method='PATCH', path=self.path, data=update_properties,
-            query_params=query_params, _target_object=self)
+            query_params={'projection': 'full'}, _target_object=self)
         self._set_properties(api_response)
 
 
diff --git a/storage/google/cloud/storage/acl.py b/storage/google/cloud/storage/acl.py
index 240662c4dc8dc..c4525ea887357 100644
--- a/storage/google/cloud/storage/acl.py
+++ b/storage/google/cloud/storage/acl.py
@@ -198,7 +198,6 @@ class ACL(object):
     # as properties).
     reload_path = None
     save_path = None
-    user_project = None
 
     def __init__(self):
         self.entities = {}
@@ -406,18 +405,10 @@ def reload(self, client=None):
         """
         path = self.reload_path
         client = self._require_client(client)
-        query_params = {}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
 
         self.entities.clear()
 
-        found = client._connection.api_request(
-            method='GET',
-            path=path,
-            query_params=query_params,
-        )
+        found = client._connection.api_request(method='GET', path=path)
         self.loaded = True
         for entry in found.get('items', ()):
             self.add_entity(self.entity_from_dict(entry))
@@ -444,12 +435,8 @@ def _save(self, acl, predefined, client):
             acl = []
             query_params[self._PREDEFINED_QUERY_PARAM] = predefined
 
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
         path = self.save_path
         client = self._require_client(client)
-
         result = client._connection.api_request(
             method='PATCH',
             path=path,
@@ -545,11 +532,6 @@ def save_path(self):
         """Compute the path for PATCH API requests for this ACL."""
         return self.bucket.path
 
-    @property
-    def user_project(self):
-        """Compute the user project charged for API requests for this ACL."""
-        return self.bucket.user_project
-
 
 class DefaultObjectACL(BucketACL):
     """A class representing the default object ACL for a bucket."""
@@ -583,8 +565,3 @@ def reload_path(self):
     def save_path(self):
         """Compute the path for PATCH API requests for this ACL."""
         return self.blob.path
-
-    @property
-    def user_project(self):
-        """Compute the user project charged for API requests for this ACL."""
-        return self.blob.user_project
diff --git a/storage/google/cloud/storage/blob.py b/storage/google/cloud/storage/blob.py
index 898d84d1b7917..de59fdf1f2bde 100644
--- a/storage/google/cloud/storage/blob.py
+++ b/storage/google/cloud/storage/blob.py
@@ -35,11 +35,7 @@
 import warnings
 
 import httplib2
-from six.moves.urllib.parse import parse_qsl
 from six.moves.urllib.parse import quote
-from six.moves.urllib.parse import urlencode
-from six.moves.urllib.parse import urlsplit
-from six.moves.urllib.parse import urlunsplit
 
 import google.auth.transport.requests
 from google import resumable_media
@@ -226,16 +222,6 @@ def client(self):
         """The client bound to this blob."""
         return self.bucket.client
 
-    @property
-    def user_project(self):
-        """Project ID used for API requests made via this blob.
-
-        Derived from bucket's value.
-
-        :rtype: str
-        """
-        return self.bucket.user_project
-
     @property
     def public_url(self):
         """The public URL for this blob's object.
@@ -344,14 +330,10 @@ 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(
@@ -407,19 +389,13 @@ def _get_download_url(self):
         :rtype: str
         :returns: The download URL for the current blob.
         """
-        name_value_pairs = []
         if self.media_link is None:
-            base_url = _DOWNLOAD_URL_TEMPLATE.format(path=self.path)
+            download_url = _DOWNLOAD_URL_TEMPLATE.format(path=self.path)
             if self.generation is not None:
-                name_value_pairs.append(
-                    ('generation', '{:d}'.format(self.generation)))
+                download_url += u'&generation={:d}'.format(self.generation)
+            return download_url
         else:
-            base_url = self.media_link
-
-        if self.user_project is not None:
-            name_value_pairs.append(('userProject', self.user_project))
-
-        return _add_query_parameters(base_url, name_value_pairs)
+            return self.media_link
 
     def _do_download(self, transport, file_obj, download_url, headers):
         """Perform a download without any error handling.
@@ -666,14 +642,8 @@ def _do_multipart_upload(self, client, stream, content_type,
         info = self._get_upload_arguments(content_type)
         headers, object_metadata, content_type = info
 
-        base_url = _MULTIPART_URL_TEMPLATE.format(
+        upload_url = _MULTIPART_URL_TEMPLATE.format(
             bucket_path=self.bucket.path)
-        name_value_pairs = []
-
-        if self.user_project is not None:
-            name_value_pairs.append(('userProject', self.user_project))
-
-        upload_url = _add_query_parameters(base_url, name_value_pairs)
         upload = MultipartUpload(upload_url, headers=headers)
 
         if num_retries is not None:
@@ -744,14 +714,8 @@ def _initiate_resumable_upload(self, client, stream, content_type,
         if extra_headers is not None:
             headers.update(extra_headers)
 
-        base_url = _RESUMABLE_URL_TEMPLATE.format(
+        upload_url = _RESUMABLE_URL_TEMPLATE.format(
             bucket_path=self.bucket.path)
-        name_value_pairs = []
-
-        if self.user_project is not None:
-            name_value_pairs.append(('userProject', self.user_project))
-
-        upload_url = _add_query_parameters(base_url, name_value_pairs)
         upload = ResumableUpload(upload_url, chunk_size, headers=headers)
 
         if num_retries is not None:
@@ -1105,16 +1069,9 @@ 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)
 
@@ -1137,18 +1094,11 @@ 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)
@@ -1172,17 +1122,12 @@ def test_iam_permissions(self, permissions, client=None):
                   request.
         """
         client = self._require_client(client)
-        query_params = {'permissions': permissions}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
+        query = {'permissions': permissions}
         path = '%s/iam/testPermissions' % (self.path,)
         resp = client._connection.api_request(
             method='GET',
             path=path,
-            query_params=query_params)
-
+            query_params=query)
         return resp.get('permissions', [])
 
     def make_public(self, client=None):
@@ -1212,22 +1157,13 @@ 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',
-            query_params=query_params,
-            data=request,
+            method='POST', path=self.path + '/compose', data=request,
             _target_object=self)
         self._set_properties(api_response)
 
@@ -1259,20 +1195,14 @@ 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
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
+            query_params = {'rewriteToken': token}
+        else:
+            query_params = {}
 
         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'])
@@ -1303,22 +1233,13 @@ 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,
-            query_params=query_params,
-            data={'storageClass': new_class},
-            headers=headers,
+            method='POST', path=self.path + '/rewriteTo' + self.path,
+            data={'storageClass': new_class}, headers=headers,
             _target_object=self)
         self._set_properties(api_response['resource'])
 
@@ -1688,24 +1609,3 @@ def _raise_from_invalid_response(error, error_info=None):
     faux_response = httplib2.Response({'status': response.status_code})
     raise make_exception(faux_response, response.content,
                          error_info=error_info, use_json=False)
-
-
-def _add_query_parameters(base_url, name_value_pairs):
-    """Add one query parameter to a base URL.
-
-    :type base_url: string
-    :param base_url: Base URL (may already contain query parameters)
-
-    :type name_value_pairs: list of (string, string) tuples.
-    :param name_value_pairs: Names and values of the query parameters to add
-
-    :rtype: string
-    :returns: URL with additional query strings appended.
-    """
-    if len(name_value_pairs) == 0:
-        return base_url
-
-    scheme, netloc, path, query, frag = urlsplit(base_url)
-    query = parse_qsl(query)
-    query.extend(name_value_pairs)
-    return urlunsplit((scheme, netloc, path, urlencode(query), frag))
diff --git a/storage/google/cloud/storage/bucket.py b/storage/google/cloud/storage/bucket.py
index e740cd4febc2e..865a23840af4a 100644
--- a/storage/google/cloud/storage/bucket.py
+++ b/storage/google/cloud/storage/bucket.py
@@ -85,10 +85,6 @@ class Bucket(_PropertyMixin):
     :type name: str
     :param name: The name of the bucket. Bucket names must start and end with a
                  number or letter.
-
-    :type user_project: str
-    :param user_project: (Optional) the project ID to be billed for API
-                         requests made via this instance.
     """
 
     _MAX_OBJECTS_FOR_ITERATION = 256
@@ -112,13 +108,12 @@ class Bucket(_PropertyMixin):
     https://cloud.google.com/storage/docs/storage-classes
     """
 
-    def __init__(self, client, name=None, user_project=None):
+    def __init__(self, client, name=None):
         name = _validate_name(name)
         super(Bucket, self).__init__(name=name)
         self._client = client
         self._acl = BucketACL(self)
         self._default_object_acl = DefaultObjectACL(self)
-        self._user_project = user_project
 
     def __repr__(self):
         return '<Bucket: %s>' % (self.name,)
@@ -128,16 +123,6 @@ def client(self):
         """The client bound to this bucket."""
         return self._client
 
-    @property
-    def user_project(self):
-        """Project ID to be billed for API requests made via this bucket.
-
-        If unset, API requests are billed to the bucket owner.
-
-        :rtype: str
-        """
-        return self._user_project
-
     def blob(self, blob_name, chunk_size=None, encryption_key=None):
         """Factory constructor for blob object.
 
@@ -175,14 +160,10 @@ def exists(self, client=None):
         :returns: True if the bucket 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(
@@ -208,9 +189,6 @@ def create(self, client=None):
         :param client: Optional. The client to use.  If not passed, falls back
                        to the ``client`` stored on the current bucket.
         """
-        if self.user_project is not None:
-            raise ValueError("Cannot create bucket with 'user_project' set.")
-
         client = self._require_client(client)
         query_params = {'project': client.project}
         properties = {key: self._properties[key] for key in self._changes}
@@ -271,18 +249,10 @@ def get_blob(self, blob_name, client=None):
         :returns: The blob object if it exists, otherwise None.
         """
         client = self._require_client(client)
-        query_params = {}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
         blob = Blob(bucket=self, name=blob_name)
         try:
             response = client._connection.api_request(
-                method='GET',
-                path=blob.path,
-                query_params=query_params,
-                _target_object=blob)
+                method='GET', path=blob.path, _target_object=blob)
             # NOTE: We assume response.get('name') matches `blob_name`.
             blob._set_properties(response)
             # NOTE: This will not fail immediately in a batch. However, when
@@ -336,7 +306,7 @@ def list_blobs(self, max_results=None, page_token=None, prefix=None,
         :returns: Iterator of all :class:`~google.cloud.storage.blob.Blob`
                   in this bucket matching the arguments.
         """
-        extra_params = {'projection': projection}
+        extra_params = {}
 
         if prefix is not None:
             extra_params['prefix'] = prefix
@@ -347,12 +317,11 @@ def list_blobs(self, max_results=None, page_token=None, prefix=None,
         if versions is not None:
             extra_params['versions'] = versions
 
+        extra_params['projection'] = projection
+
         if fields is not None:
             extra_params['fields'] = fields
 
-        if self.user_project is not None:
-            extra_params['userProject'] = self.user_project
-
         client = self._require_client(client)
         path = self.path + '/o'
         iterator = HTTPIterator(
@@ -392,11 +361,6 @@ def delete(self, force=False, client=None):
                  contains more than 256 objects / blobs.
         """
         client = self._require_client(client)
-        query_params = {}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
         if force:
             blobs = list(self.list_blobs(
                 max_results=self._MAX_OBJECTS_FOR_ITERATION + 1,
@@ -418,10 +382,7 @@ def delete(self, force=False, client=None):
         # request has no response value (whether in a standard request or
         # in a batch request).
         client._connection.api_request(
-            method='DELETE',
-            path=self.path,
-            query_params=query_params,
-            _target_object=None)
+            method='DELETE', path=self.path, _target_object=None)
 
     def delete_blob(self, blob_name, client=None):
         """Deletes a blob from the current bucket.
@@ -453,20 +414,12 @@ def delete_blob(self, blob_name, client=None):
 
         """
         client = self._require_client(client)
-        query_params = {}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
         blob_path = Blob.path_helper(self.path, blob_name)
         # We intentionally pass `_target_object=None` since a DELETE
         # request has no response value (whether in a standard request or
         # in a batch request).
         client._connection.api_request(
-            method='DELETE',
-            path=blob_path,
-            query_params=query_params,
-            _target_object=None)
+            method='DELETE', path=blob_path, _target_object=None)
 
     def delete_blobs(self, blobs, on_error=None, client=None):
         """Deletes a list of blobs from the current bucket.
@@ -529,26 +482,14 @@ def copy_blob(self, blob, destination_bucket, new_name=None,
         :returns: The new Blob.
         """
         client = self._require_client(client)
-        query_params = {}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
         if new_name is None:
             new_name = blob.name
-
         new_blob = Blob(bucket=destination_bucket, name=new_name)
         api_path = blob.path + '/copyTo' + new_blob.path
         copy_result = client._connection.api_request(
-            method='POST',
-            path=api_path,
-            query_params=query_params,
-            _target_object=new_blob,
-            )
-
+            method='POST', path=api_path, _target_object=new_blob)
         if not preserve_acl:
             new_blob.acl.save(acl={}, client=client)
-
         new_blob._set_properties(copy_result)
         return new_blob
 
@@ -857,40 +798,10 @@ def versioning_enabled(self, value):
         details.
 
         :type value: convertible to boolean
-        :param value: should versioning be enabled for the bucket?
+        :param value: should versioning be anabled for the bucket?
         """
         self._patch_property('versioning', {'enabled': bool(value)})
 
-    @property
-    def requester_pays(self):
-        """Does the requester pay for API requests for this bucket?
-
-        .. note::
-
-           No public docs exist yet for the "requester pays" feature.
-
-        :setter: Update whether requester pays for this bucket.
-        :getter: Query whether requester pays for this bucket.
-
-        :rtype: bool
-        :returns: True if requester pays for API requests for the bucket,
-                  else False.
-        """
-        versioning = self._properties.get('billing', {})
-        return versioning.get('requesterPays', False)
-
-    @requester_pays.setter
-    def requester_pays(self, value):
-        """Update whether requester pays for API requests for this bucket.
-
-        See  https://cloud.google.com/storage/docs/<DOCS-MISSING> for
-        details.
-
-        :type value: convertible to boolean
-        :param value: should requester pay for API requests for the bucket?
-        """
-        self._patch_property('billing', {'requesterPays': bool(value)})
-
     def configure_website(self, main_page_suffix=None, not_found_page=None):
         """Configure website-related properties.
 
@@ -956,15 +867,9 @@ 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)
 
@@ -987,17 +892,11 @@ 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)
@@ -1021,16 +920,12 @@ def test_iam_permissions(self, permissions, client=None):
                   request.
         """
         client = self._require_client(client)
-        query_params = {'permissions': permissions}
-
-        if self.user_project is not None:
-            query_params['userProject'] = self.user_project
-
+        query = {'permissions': permissions}
         path = '%s/iam/testPermissions' % (self.path,)
         resp = client._connection.api_request(
             method='GET',
             path=path,
-            query_params=query_params)
+            query_params=query)
         return resp.get('permissions', [])
 
     def make_public(self, recursive=False, future=False, client=None):
diff --git a/storage/google/cloud/storage/client.py b/storage/google/cloud/storage/client.py
index 51cad4d70c54b..93785e05269fc 100644
--- a/storage/google/cloud/storage/client.py
+++ b/storage/google/cloud/storage/client.py
@@ -194,7 +194,7 @@ def lookup_bucket(self, bucket_name):
         except NotFound:
             return None
 
-    def create_bucket(self, bucket_name, requester_pays=None):
+    def create_bucket(self, bucket_name):
         """Create a new bucket.
 
         For example:
@@ -211,17 +211,10 @@ def create_bucket(self, bucket_name, requester_pays=None):
         :type bucket_name: str
         :param bucket_name: The bucket name to create.
 
-        :type requester_pays: bool
-        :param requester_pays:
-            (Optional) Whether requester pays for API requests for this
-            bucket and its blobs.
-
         :rtype: :class:`google.cloud.storage.bucket.Bucket`
         :returns: The newly created bucket.
         """
         bucket = Bucket(self, name=bucket_name)
-        if requester_pays is not None:
-            bucket.requester_pays = requester_pays
         bucket.create(client=self)
         return bucket
 
diff --git a/storage/tests/system.py b/storage/tests/system.py
index 06f50b26128b5..afab659882bfc 100644
--- a/storage/tests/system.py
+++ b/storage/tests/system.py
@@ -30,8 +30,6 @@
 
 HTTP = httplib2.Http()
 
-REQUESTER_PAYS_ENABLED = False  # query from environment?
-
 
 def _bad_copy(bad_request):
     """Predicate: pass only exceptions for a failed copyTo."""
@@ -101,15 +99,6 @@ def test_create_bucket(self):
         self.case_buckets_to_delete.append(new_bucket_name)
         self.assertEqual(created.name, new_bucket_name)
 
-    @unittest.skipUnless(REQUESTER_PAYS_ENABLED, "requesterPays not enabled")
-    def test_create_bucket_with_requester_pays(self):
-        new_bucket_name = 'w-requester-pays' + unique_resource_id('-')
-        created = Config.CLIENT.create_bucket(
-            new_bucket_name, requester_pays=True)
-        self.case_buckets_to_delete.append(new_bucket_name)
-        self.assertEqual(created.name, new_bucket_name)
-        self.assertTrue(created.requester_pays)
-
     def test_list_buckets(self):
         buckets_to_create = [
             'new' + unique_resource_id(),
diff --git a/storage/tests/unit/test__helpers.py b/storage/tests/unit/test__helpers.py
index 21883e2c4ac9a..89967f3a0db09 100644
--- a/storage/tests/unit/test__helpers.py
+++ b/storage/tests/unit/test__helpers.py
@@ -26,7 +26,7 @@ def _get_target_class():
     def _make_one(self, *args, **kw):
         return self._get_target_class()(*args, **kw)
 
-    def _derivedClass(self, path=None, user_project=None):
+    def _derivedClass(self, path=None):
 
         class Derived(self._get_target_class()):
 
@@ -36,67 +36,30 @@ class Derived(self._get_target_class()):
             def path(self):
                 return path
 
-            @property
-            def user_project(self):
-                return user_project
-
         return Derived
 
     def test_path_is_abstract(self):
         mixin = self._make_one()
-        with self.assertRaises(NotImplementedError):
-            mixin.path
+        self.assertRaises(NotImplementedError, lambda: mixin.path)
 
     def test_client_is_abstract(self):
         mixin = self._make_one()
-        with self.assertRaises(NotImplementedError):
-            mixin.client
-
-    def test_user_project_is_abstract(self):
-        mixin = self._make_one()
-        with self.assertRaises(NotImplementedError):
-            mixin.user_project
+        self.assertRaises(NotImplementedError, lambda: mixin.client)
 
     def test_reload(self):
         connection = _Connection({'foo': 'Foo'})
         client = _Client(connection)
         derived = self._derivedClass('/path')()
-        # Make sure changes is not a set instance before calling reload
-        # (which will clear / replace it with an empty set), checked below.
-        derived._changes = object()
-        derived.reload(client=client)
-        self.assertEqual(derived._properties, {'foo': 'Foo'})
-        kw = connection._requested
-        self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'GET',
-            'path': '/path',
-            'query_params': {'projection': 'noAcl'},
-            '_target_object': derived,
-        })
-        self.assertEqual(derived._changes, set())
-
-    def test_reload_w_user_project(self):
-        user_project = 'user-project-123'
-        connection = _Connection({'foo': 'Foo'})
-        client = _Client(connection)
-        derived = self._derivedClass('/path', user_project)()
-        # Make sure changes is not a set instance before calling reload
-        # (which will clear / replace it with an empty set), checked below.
+        # Make sure changes is not a set, so we can observe a change.
         derived._changes = object()
         derived.reload(client=client)
         self.assertEqual(derived._properties, {'foo': 'Foo'})
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'GET',
-            'path': '/path',
-            'query_params': {
-                'projection': 'noAcl',
-                'userProject': user_project,
-            },
-            '_target_object': derived,
-        })
+        self.assertEqual(kw[0]['method'], 'GET')
+        self.assertEqual(kw[0]['path'], '/path')
+        self.assertEqual(kw[0]['query_params'], {'projection': 'noAcl'})
+        # Make sure changes get reset by reload.
         self.assertEqual(derived._changes, set())
 
     def test__set_properties(self):
@@ -124,42 +87,11 @@ def test_patch(self):
         self.assertEqual(derived._properties, {'foo': 'Foo'})
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/path',
-            'query_params': {'projection': 'full'},
-            # Since changes does not include `baz`, we don't see it sent.
-            'data': {'bar': BAR},
-            '_target_object': derived,
-        })
-        # Make sure changes get reset by patch().
-        self.assertEqual(derived._changes, set())
-
-    def test_patch_w_user_project(self):
-        user_project = 'user-project-123'
-        connection = _Connection({'foo': 'Foo'})
-        client = _Client(connection)
-        derived = self._derivedClass('/path', user_project)()
-        # Make sure changes is non-empty, so we can observe a change.
-        BAR = object()
-        BAZ = object()
-        derived._properties = {'bar': BAR, 'baz': BAZ}
-        derived._changes = set(['bar'])  # Ignore baz.
-        derived.patch(client=client)
-        self.assertEqual(derived._properties, {'foo': 'Foo'})
-        kw = connection._requested
-        self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/path',
-            'query_params': {
-                'projection': 'full',
-                'userProject': user_project,
-            },
-            # Since changes does not include `baz`, we don't see it sent.
-            'data': {'bar': BAR},
-            '_target_object': derived,
-        })
+        self.assertEqual(kw[0]['method'], 'PATCH')
+        self.assertEqual(kw[0]['path'], '/path')
+        self.assertEqual(kw[0]['query_params'], {'projection': 'full'})
+        # Since changes does not include `baz`, we don't see it sent.
+        self.assertEqual(kw[0]['data'], {'bar': BAR})
         # Make sure changes get reset by patch().
         self.assertEqual(derived._changes, set())
 
diff --git a/storage/tests/unit/test_acl.py b/storage/tests/unit/test_acl.py
index 4e4018ae7c8cf..1159c8c1f2aac 100644
--- a/storage/tests/unit/test_acl.py
+++ b/storage/tests/unit/test_acl.py
@@ -532,11 +532,8 @@ def test_reload_missing(self):
         self.assertEqual(list(acl), [])
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'GET',
-            'path': '/testing/acl',
-            'query_params': {},
-        })
+        self.assertEqual(kw[0]['method'], 'GET')
+        self.assertEqual(kw[0]['path'], '/testing/acl')
 
     def test_reload_empty_result_clears_local(self):
         ROLE = 'role'
@@ -546,41 +543,29 @@ def test_reload_empty_result_clears_local(self):
         acl.reload_path = '/testing/acl'
         acl.loaded = True
         acl.entity('allUsers', ROLE)
-
         acl.reload(client=client)
-
         self.assertTrue(acl.loaded)
         self.assertEqual(list(acl), [])
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'GET',
-            'path': '/testing/acl',
-            'query_params': {},
-        })
+        self.assertEqual(kw[0]['method'], 'GET')
+        self.assertEqual(kw[0]['path'], '/testing/acl')
 
-    def test_reload_nonempty_result_w_user_project(self):
+    def test_reload_nonempty_result(self):
         ROLE = 'role'
-        USER_PROJECT = 'user-project-123'
         connection = _Connection(
             {'items': [{'entity': 'allUsers', 'role': ROLE}]})
         client = _Client(connection)
         acl = self._make_one()
         acl.reload_path = '/testing/acl'
         acl.loaded = True
-        acl.user_project = USER_PROJECT
-
         acl.reload(client=client)
-
         self.assertTrue(acl.loaded)
         self.assertEqual(list(acl), [{'entity': 'allUsers', 'role': ROLE}])
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'GET',
-            'path': '/testing/acl',
-            'query_params': {'userProject': USER_PROJECT},
-        })
+        self.assertEqual(kw[0]['method'], 'GET')
+        self.assertEqual(kw[0]['path'], '/testing/acl')
 
     def test_save_none_set_none_passed(self):
         connection = _Connection()
@@ -621,43 +606,30 @@ def test_save_no_acl(self):
         self.assertEqual(len(kw), 1)
         self.assertEqual(kw[0]['method'], 'PATCH')
         self.assertEqual(kw[0]['path'], '/testing')
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/testing',
-            'query_params': {'projection': 'full'},
-            'data': {'acl': AFTER},
-        })
-
-    def test_save_w_acl_w_user_project(self):
+        self.assertEqual(kw[0]['data'], {'acl': AFTER})
+        self.assertEqual(kw[0]['query_params'], {'projection': 'full'})
+
+    def test_save_w_acl(self):
         ROLE1 = 'role1'
         ROLE2 = 'role2'
         STICKY = {'entity': 'allUsers', 'role': ROLE2}
-        USER_PROJECT = 'user-project-123'
         new_acl = [{'entity': 'allUsers', 'role': ROLE1}]
         connection = _Connection({'acl': [STICKY] + new_acl})
         client = _Client(connection)
         acl = self._make_one()
         acl.save_path = '/testing'
         acl.loaded = True
-        acl.user_project = USER_PROJECT
-
         acl.save(new_acl, client=client)
-
         entries = list(acl)
         self.assertEqual(len(entries), 2)
         self.assertTrue(STICKY in entries)
         self.assertTrue(new_acl[0] in entries)
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/testing',
-            'query_params': {
-                'projection': 'full',
-                'userProject': USER_PROJECT,
-            },
-            'data': {'acl': new_acl},
-        })
+        self.assertEqual(kw[0]['method'], 'PATCH')
+        self.assertEqual(kw[0]['path'], '/testing')
+        self.assertEqual(kw[0]['data'], {'acl': new_acl})
+        self.assertEqual(kw[0]['query_params'], {'projection': 'full'})
 
     def test_save_prefefined_invalid(self):
         connection = _Connection()
@@ -680,15 +652,11 @@ def test_save_predefined_valid(self):
         self.assertEqual(len(entries), 0)
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/testing',
-            'query_params': {
-                'projection': 'full',
-                'predefinedAcl': PREDEFINED,
-            },
-            'data': {'acl': []},
-        })
+        self.assertEqual(kw[0]['method'], 'PATCH')
+        self.assertEqual(kw[0]['path'], '/testing')
+        self.assertEqual(kw[0]['data'], {'acl': []})
+        self.assertEqual(kw[0]['query_params'],
+                         {'projection': 'full', 'predefinedAcl': PREDEFINED})
 
     def test_save_predefined_w_XML_alias(self):
         PREDEFINED_XML = 'project-private'
@@ -703,15 +671,12 @@ def test_save_predefined_w_XML_alias(self):
         self.assertEqual(len(entries), 0)
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/testing',
-            'query_params': {
-                'projection': 'full',
-                'predefinedAcl': PREDEFINED_JSON,
-            },
-            'data': {'acl': []},
-        })
+        self.assertEqual(kw[0]['method'], 'PATCH')
+        self.assertEqual(kw[0]['path'], '/testing')
+        self.assertEqual(kw[0]['data'], {'acl': []})
+        self.assertEqual(kw[0]['query_params'],
+                         {'projection': 'full',
+                          'predefinedAcl': PREDEFINED_JSON})
 
     def test_save_predefined_valid_w_alternate_query_param(self):
         # Cover case where subclass overrides _PREDEFINED_QUERY_PARAM
@@ -727,15 +692,11 @@ def test_save_predefined_valid_w_alternate_query_param(self):
         self.assertEqual(len(entries), 0)
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/testing',
-            'query_params': {
-                'projection': 'full',
-                'alternate': PREDEFINED,
-            },
-            'data': {'acl': []},
-        })
+        self.assertEqual(kw[0]['method'], 'PATCH')
+        self.assertEqual(kw[0]['path'], '/testing')
+        self.assertEqual(kw[0]['data'], {'acl': []})
+        self.assertEqual(kw[0]['query_params'],
+                         {'projection': 'full', 'alternate': PREDEFINED})
 
     def test_clear(self):
         ROLE1 = 'role1'
@@ -751,12 +712,10 @@ def test_clear(self):
         self.assertEqual(list(acl), [STICKY])
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        self.assertEqual(kw[0], {
-            'method': 'PATCH',
-            'path': '/testing',
-            'query_params': {'projection': 'full'},
-            'data': {'acl': []},
-        })
+        self.assertEqual(kw[0]['method'], 'PATCH')
+        self.assertEqual(kw[0]['path'], '/testing')
+        self.assertEqual(kw[0]['data'], {'acl': []})
+        self.assertEqual(kw[0]['query_params'], {'projection': 'full'})
 
 
 class Test_BucketACL(unittest.TestCase):
@@ -780,15 +739,6 @@ def test_ctor(self):
         self.assertEqual(acl.reload_path, '/b/%s/acl' % NAME)
         self.assertEqual(acl.save_path, '/b/%s' % NAME)
 
-    def test_user_project(self):
-        NAME = 'name'
-        USER_PROJECT = 'user-project-123'
-        bucket = _Bucket(NAME)
-        acl = self._make_one(bucket)
-        self.assertIsNone(acl.user_project)
-        bucket.user_project = USER_PROJECT
-        self.assertEqual(acl.user_project, USER_PROJECT)
-
 
 class Test_DefaultObjectACL(unittest.TestCase):
 
@@ -835,22 +785,9 @@ def test_ctor(self):
         self.assertEqual(acl.reload_path, '/b/%s/o/%s/acl' % (NAME, BLOB_NAME))
         self.assertEqual(acl.save_path, '/b/%s/o/%s' % (NAME, BLOB_NAME))
 
-    def test_user_project(self):
-        NAME = 'name'
-        BLOB_NAME = 'blob-name'
-        USER_PROJECT = 'user-project-123'
-        bucket = _Bucket(NAME)
-        blob = _Blob(bucket, BLOB_NAME)
-        acl = self._make_one(blob)
-        self.assertIsNone(acl.user_project)
-        blob.user_project = USER_PROJECT
-        self.assertEqual(acl.user_project, USER_PROJECT)
-
 
 class _Blob(object):
 
-    user_project = None
-
     def __init__(self, bucket, blob):
         self.bucket = bucket
         self.blob = blob
@@ -862,8 +799,6 @@ def path(self):
 
 class _Bucket(object):
 
-    user_project = None
-
     def __init__(self, name):
         self.name = name
 
diff --git a/storage/tests/unit/test_blob.py b/storage/tests/unit/test_blob.py
index ad0f88b5129f3..a5d49bc4bacb6 100644
--- a/storage/tests/unit/test_blob.py
+++ b/storage/tests/unit/test_blob.py
@@ -141,19 +141,6 @@ def test_path_with_non_ascii(self):
         blob = self._make_one(blob_name, bucket=bucket)
         self.assertEqual(blob.path, '/b/name/o/Caf%C3%A9')
 
-    def test_client(self):
-        blob_name = 'BLOB'
-        bucket = _Bucket()
-        blob = self._make_one(blob_name, bucket=bucket)
-        self.assertIs(blob.client, bucket.client)
-
-    def test_user_project(self):
-        user_project = 'user-project-123'
-        blob_name = 'BLOB'
-        bucket = _Bucket(user_project=user_project)
-        blob = self._make_one(blob_name, bucket=bucket)
-        self.assertEqual(blob.user_project, user_project)
-
     def test_public_url(self):
         BLOB_NAME = 'blob-name'
         bucket = _Bucket()
@@ -317,31 +304,16 @@ 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_w_user_project(self):
+    def test_exists_hit(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, user_project=USER_PROJECT)
+        bucket = _Bucket(client)
         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'
@@ -366,7 +338,7 @@ def test__make_transport(self, fake_session_factory):
 
     def test__get_download_url_with_media_link(self):
         blob_name = 'something.txt'
-        bucket = _Bucket(name='IRRELEVANT')
+        bucket = mock.Mock(spec=[])
         blob = self._make_one(blob_name, bucket=bucket)
         media_link = 'http://test.invalid'
         # Set the media link on the blob
@@ -375,22 +347,9 @@ def test__get_download_url_with_media_link(self):
         download_url = blob._get_download_url()
         self.assertEqual(download_url, media_link)
 
-    def test__get_download_url_with_media_link_w_user_project(self):
-        blob_name = 'something.txt'
-        user_project = 'user-project-123'
-        bucket = _Bucket(name='IRRELEVANT', user_project=user_project)
-        blob = self._make_one(blob_name, bucket=bucket)
-        media_link = 'http://test.invalid'
-        # Set the media link on the blob
-        blob._properties['mediaLink'] = media_link
-
-        download_url = blob._get_download_url()
-        self.assertEqual(
-            download_url, '{}?userProject={}'.format(media_link, user_project))
-
     def test__get_download_url_on_the_fly(self):
         blob_name = 'bzzz-fly.txt'
-        bucket = _Bucket(name='buhkit')
+        bucket = mock.Mock(path='/b/buhkit', spec=['path'])
         blob = self._make_one(blob_name, bucket=bucket)
 
         self.assertIsNone(blob.media_link)
@@ -402,7 +361,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 = _Bucket(name='fictional')
+        bucket = mock.Mock(path='/b/fictional', spec=['path'])
         blob = self._make_one(blob_name, bucket=bucket)
         generation = 1493058489532987
         # Set the media link on the blob
@@ -415,20 +374,6 @@ 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(
@@ -820,8 +765,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, user_project=None):
-        bucket = _Bucket(name='w00t', user_project=user_project)
+                              num_retries=None):
+        bucket = mock.Mock(path='/b/w00t', spec=[u'path'])
         blob = self._make_one(u'blob-name', bucket=bucket)
         self.assertIsNone(blob.chunk_size)
 
@@ -853,8 +798,6 @@ 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' +
@@ -877,13 +820,6 @@ 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):
@@ -905,12 +841,11 @@ 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, user_project=None):
+    def _initiate_resumable_helper(self, size=None, extra_headers=None,
+                                   chunk_size=None, num_retries=None):
         from google.resumable_media.requests import ResumableUpload
 
-        bucket = _Bucket(name='whammy', user_project=user_project)
+        bucket = mock.Mock(path='/b/whammy', spec=[u'path'])
         blob = self._make_one(u'blob-name', bucket=bucket)
         blob.metadata = {'rook': 'takes knight'}
         blob.chunk_size = 3 * blob._CHUNK_SIZE_MULTIPLE
@@ -944,8 +879,6 @@ def _initiate_resumable_helper(
             '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, {})
@@ -998,10 +931,6 @@ 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)
@@ -1081,7 +1010,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 = _Bucket(name='yesterday')
+        bucket = mock.Mock(path='/b/yesterday', spec=[u'path'])
         blob = self._make_one(u'blob-name', bucket=bucket)
         blob.chunk_size = blob._CHUNK_SIZE_MULTIPLE
         self.assertIsNotNone(blob.chunk_size)
@@ -1324,7 +1253,7 @@ def test_upload_from_string_w_text(self):
 
     def _create_resumable_upload_session_helper(self, origin=None,
                                                 side_effect=None):
-        bucket = _Bucket(name='alex-trebek')
+        bucket = mock.Mock(path='/b/alex-trebek', spec=[u'path'])
         blob = self._make_one('blob-name', bucket=bucket)
         chunk_size = 99 * blob._CHUNK_SIZE_MULTIPLE
         blob.chunk_size = chunk_size
@@ -1435,49 +1364,8 @@ def test_get_iam_policy(self):
 
         kw = connection._requested
         self.assertEqual(len(kw), 1)
-        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,
-        })
+        self.assertEqual(kw[0]['method'], 'GET')
+        self.assertEqual(kw[0]['path'], '%s/iam' % (PATH,))
 
     def test_set_iam_policy(self):
         import operator
@@ -1526,7 +1414,6 @@ 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))
@@ -1538,41 +1425,6 @@ 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
@@ -1603,39 +1455,6 @@ 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
 
@@ -1670,18 +1489,17 @@ def test_compose_wo_content_type_set(self):
         with self.assertRaises(ValueError):
             destination.compose(sources=[source_1, source_2])
 
-    def test_compose_minimal_w_user_project(self):
+    def test_compose_minimal(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, user_project=USER_PROJECT)
+        bucket = _Bucket(client=client)
         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)
@@ -1691,23 +1509,20 @@ def test_compose_minimal_w_user_project(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',
-            '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,
-        })
+        self.assertEqual(kw[0]['method'], 'POST')
+        self.assertEqual(kw[0]['path'], '/b/name/o/%s/compose' % DESTINATION)
+        self.assertEqual(kw[0]['data'], SENT)
 
     def test_compose_w_additional_property_changes(self):
         SOURCE_1 = 'source-1'
@@ -1731,27 +1546,24 @@ 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',
-            '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,
-        })
+        self.assertEqual(kw[0]['method'], 'POST')
+        self.assertEqual(kw[0]['path'], '/b/name/o/%s/compose' % DESTINATION)
+        self.assertEqual(kw[0]['data'], SENT)
 
     def test_rewrite_response_without_resource(self):
         SOURCE_BLOB = 'source'
@@ -1823,7 +1635,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_w_user_project(self):
+    def test_rewrite_same_name_no_old_key_new_key_done(self):
         import base64
         import hashlib
 
@@ -1832,7 +1644,6 @@ def test_rewrite_same_name_no_old_key_new_key_done_w_user_project(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,
@@ -1842,7 +1653,7 @@ def test_rewrite_same_name_no_old_key_new_key_done_w_user_project(self):
         response = ({'status': http_client.OK}, RESPONSE)
         connection = _Connection(response)
         client = _Client(connection)
-        bucket = _Bucket(client=client, user_project=USER_PROJECT)
+        bucket = _Bucket(client=client)
         plain = self._make_one(BLOB_NAME, bucket=bucket)
         encrypted = self._make_one(BLOB_NAME, bucket=bucket,
                                    encryption_key=KEY)
@@ -1858,7 +1669,7 @@ def test_rewrite_same_name_no_old_key_new_key_done_w_user_project(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'], {'userProject': USER_PROJECT})
+        self.assertEqual(kw[0]['query_params'], {})
         SENT = {}
         self.assertEqual(kw[0]['data'], SENT)
 
@@ -1961,7 +1772,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.assertEqual(kw[0]['query_params'], {})
+        self.assertNotIn('query_params', kw[0])
         SENT = {'storageClass': STORAGE_CLASS}
         self.assertEqual(kw[0]['data'], SENT)
 
@@ -1975,7 +1786,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_w_user_project(self):
+    def test_update_storage_class_w_encryption_key(self):
         import base64
         import hashlib
 
@@ -1986,14 +1797,13 @@ def test_update_storage_class_w_encryption_key_w_user_project(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, user_project=USER_PROJECT)
+        bucket = _Bucket(client=client)
         blob = self._make_one(
             BLOB_NAME, bucket=bucket, encryption_key=BLOB_KEY)
 
@@ -2006,7 +1816,7 @@ def test_update_storage_class_w_encryption_key_w_user_project(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'], {'userProject': USER_PROJECT})
+        self.assertNotIn('query_params', kw[0])
         SENT = {'storageClass': STORAGE_CLASS}
         self.assertEqual(kw[0]['data'], SENT)
 
@@ -2443,37 +2253,6 @@ def test_with_error_info(self):
         self.assertEqual(exc_info.exception.errors, [])
 
 
-class Test__add_query_parameters(unittest.TestCase):
-
-    @staticmethod
-    def _call_fut(*args, **kwargs):
-        from google.cloud.storage.blob import _add_query_parameters
-
-        return _add_query_parameters(*args, **kwargs)
-
-    def test_w_empty_list(self):
-        BASE_URL = 'https://test.example.com/base'
-        self.assertEqual(self._call_fut(BASE_URL, []), BASE_URL)
-
-    def test_wo_existing_qs(self):
-        BASE_URL = 'https://test.example.com/base'
-        NV_LIST = [('one', 'One'), ('two', 'Two')]
-        expected = '&'.join([
-            '{}={}'.format(name, value) for name, value in NV_LIST])
-        self.assertEqual(
-            self._call_fut(BASE_URL, NV_LIST),
-            '{}?{}'.format(BASE_URL, expected))
-
-    def test_w_existing_qs(self):
-        BASE_URL = 'https://test.example.com/base?one=Three'
-        NV_LIST = [('one', 'One'), ('two', 'Two')]
-        expected = '&'.join([
-            '{}={}'.format(name, value) for name, value in NV_LIST])
-        self.assertEqual(
-            self._call_fut(BASE_URL, NV_LIST),
-            '{}&{}'.format(BASE_URL, expected))
-
-
 class _Connection(object):
 
     API_BASE_URL = 'http://example.com'
@@ -2501,7 +2280,7 @@ def api_request(self, **kw):
 
 class _Bucket(object):
 
-    def __init__(self, client=None, name='name', user_project=None):
+    def __init__(self, client=None, name='name'):
         if client is None:
             connection = _Connection()
             client = _Client(connection)
@@ -2511,7 +2290,6 @@ def __init__(self, client=None, name='name', user_project=None):
         self._deleted = []
         self.name = name
         self.path = '/b/' + name
-        self.user_project = user_project
 
     def delete_blob(self, blob_name, client=None):
         del self._blobs[blob_name]
diff --git a/storage/tests/unit/test_bucket.py b/storage/tests/unit/test_bucket.py
index b6231fa2192ac..5e4a915751977 100644
--- a/storage/tests/unit/test_bucket.py
+++ b/storage/tests/unit/test_bucket.py
@@ -33,21 +33,13 @@ class _SigningCredentials(
 
 class Test_Bucket(unittest.TestCase):
 
-    @staticmethod
-    def _get_target_class():
+    def _make_one(self, client=None, name=None, properties=None):
         from google.cloud.storage.bucket import Bucket
-        return Bucket
 
-    def _make_one(
-            self, client=None, name=None, properties=None, user_project=None):
         if client is None:
             connection = _Connection()
             client = _Client(connection)
-        if user_project is None:
-            bucket = self._get_target_class()(client, name=name)
-        else:
-            bucket = self._get_target_class()(
-                client, name=name, user_project=user_project)
+        bucket = Bucket(client, name=name)
         bucket._properties = properties or {}
         return bucket
 
@@ -61,21 +53,6 @@ def test_ctor(self):
         self.assertIs(bucket._acl.bucket, bucket)
         self.assertFalse(bucket._default_object_acl.loaded)
         self.assertIs(bucket._default_object_acl.bucket, bucket)
-        self.assertIsNone(bucket.user_project)
-
-    def test_ctor_w_user_project(self):
-        NAME = 'name'
-        USER_PROJECT = 'user-project-123'
-        connection = _Connection()
-        client = _Client(connection)
-        bucket = self._make_one(client, name=NAME, user_project=USER_PROJECT)
-        self.assertEqual(bucket.name, NAME)
-        self.assertEqual(bucket._properties, {})
-        self.assertEqual(bucket.user_project, USER_PROJECT)
-        self.assertFalse(bucket._acl.loaded)
-        self.assertIs(bucket._acl.bucket, bucket)
-        self.assertFalse(bucket._default_object_acl.loaded)
-        self.assertIs(bucket._default_object_acl.bucket, bucket)
 
     def test_blob(self):
         from google.cloud.storage.blob import Blob
@@ -96,8 +73,9 @@ def test_blob(self):
         self.assertEqual(blob._encryption_key, KEY)
 
     def test_bucket_name_value(self):
-        BUCKET_NAME = 'bucket-name'
-        bucket = self._make_one(name=BUCKET_NAME)
+        bucket_name = 'testing123'
+        mixin = self._make_one(name=bucket_name)
+        self.assertEqual(mixin.name, bucket_name)
 
         bad_start_bucket_name = '/testing123'
         with self.assertRaises(ValueError):
@@ -107,13 +85,6 @@ def test_bucket_name_value(self):
         with self.assertRaises(ValueError):
             self._make_one(name=bad_end_bucket_name)
 
-    def test_user_project(self):
-        BUCKET_NAME = 'name'
-        USER_PROJECT = 'user-project-123'
-        bucket = self._make_one(name=BUCKET_NAME)
-        bucket._user_project = USER_PROJECT
-        self.assertEqual(bucket.user_project, USER_PROJECT)
-
     def test_exists_miss(self):
         from google.cloud.exceptions import NotFound
 
@@ -141,9 +112,7 @@ def api_request(cls, *args, **kwargs):
         expected_cw = [((), expected_called_kwargs)]
         self.assertEqual(_FakeConnection._called_with, expected_cw)
 
-    def test_exists_hit_w_user_project(self):
-        USER_PROJECT = 'user-project-123'
-
+    def test_exists_hit(self):
         class _FakeConnection(object):
 
             _called_with = []
@@ -155,7 +124,7 @@ def api_request(cls, *args, **kwargs):
                 return object()
 
         BUCKET_NAME = 'bucket-name'
-        bucket = self._make_one(name=BUCKET_NAME, user_project=USER_PROJECT)
+        bucket = self._make_one(name=BUCKET_NAME)
         client = _Client(_FakeConnection)
         self.assertTrue(bucket.exists(client=client))
         expected_called_kwargs = {
@@ -163,29 +132,17 @@ def api_request(cls, *args, **kwargs):
             'path': bucket.path,
             'query_params': {
                 'fields': 'name',
-                'userProject': USER_PROJECT,
             },
             '_target_object': None,
         }
         expected_cw = [((), expected_called_kwargs)]
         self.assertEqual(_FakeConnection._called_with, expected_cw)
 
-    def test_create_w_user_project(self):
-        PROJECT = 'PROJECT'
-        BUCKET_NAME = 'bucket-name'
-        USER_PROJECT = 'user-project-123'
-        connection = _Connection()
-        client = _Client(connection, project=PROJECT)
-        bucket = self._make_one(client, BUCKET_NAME, user_project=USER_PROJECT)
-
-        with self.assertRaises(ValueError):
-            bucket.create()
-
     def test_create_hit(self):
-        PROJECT = 'PROJECT'
         BUCKET_NAME = 'bucket-name'
         DATA = {'name': BUCKET_NAME}
         connection = _Connection(DATA)
+        PROJECT = 'PROJECT'
         client = _Client(connection, project=PROJECT)
         bucket = self._make_one(client=client, name=BUCKET_NAME)
         bucket.create()
@@ -219,7 +176,6 @@ def test_create_w_extra_properties(self):
             'location': LOCATION,
             'storageClass': STORAGE_CLASS,
             'versioning': {'enabled': True},
-            'billing': {'requesterPays': True},
             'labels': LABELS,
         }
         connection = _Connection(DATA)
@@ -230,7 +186,6 @@ def test_create_w_extra_properties(self):
         bucket.location = LOCATION
         bucket.storage_class = STORAGE_CLASS
         bucket.versioning_enabled = True
-        bucket.requester_pays = True
         bucket.labels = LABELS
         bucket.create()
 
@@ -277,20 +232,18 @@ def test_get_blob_miss(self):
         self.assertEqual(kw['method'], 'GET')
         self.assertEqual(kw['path'], '/b/%s/o/%s' % (NAME, NONESUCH))
 
-    def test_get_blob_hit_w_user_project(self):
+    def test_get_blob_hit(self):
         NAME = 'name'
         BLOB_NAME = 'blob-name'
-        USER_PROJECT = 'user-project-123'
         connection = _Connection({'name': BLOB_NAME})
         client = _Client(connection)
-        bucket = self._make_one(name=NAME, user_project=USER_PROJECT)
+        bucket = self._make_one(name=NAME)
         blob = bucket.get_blob(BLOB_NAME, client=client)
         self.assertIs(blob.bucket, bucket)
         self.assertEqual(blob.name, BLOB_NAME)
         kw, = connection._requested
         self.assertEqual(kw['method'], 'GET')
         self.assertEqual(kw['path'], '/b/%s/o/%s' % (NAME, BLOB_NAME))
-        self.assertEqual(kw['query_params'], {'userProject': USER_PROJECT})
 
     def test_list_blobs_defaults(self):
         NAME = 'name'
@@ -305,9 +258,8 @@ def test_list_blobs_defaults(self):
         self.assertEqual(kw['path'], '/b/%s/o' % NAME)
         self.assertEqual(kw['query_params'], {'projection': 'noAcl'})
 
-    def test_list_blobs_w_all_arguments_and_user_project(self):
+    def test_list_blobs_w_all_arguments(self):
         NAME = 'name'
-        USER_PROJECT = 'user-project-123'
         MAX_RESULTS = 10
         PAGE_TOKEN = 'ABCD'
         PREFIX = 'subfolder'
@@ -323,11 +275,10 @@ def test_list_blobs_w_all_arguments_and_user_project(self):
             'versions': VERSIONS,
             'projection': PROJECTION,
             'fields': FIELDS,
-            'userProject': USER_PROJECT,
         }
         connection = _Connection({'items': []})
         client = _Client(connection)
-        bucket = self._make_one(name=NAME, user_project=USER_PROJECT)
+        bucket = self._make_one(name=NAME)
         iterator = bucket.list_blobs(
             max_results=MAX_RESULTS,
             page_token=PAGE_TOKEN,
@@ -369,27 +320,23 @@ def test_delete_miss(self):
         expected_cw = [{
             'method': 'DELETE',
             'path': bucket.path,
-            'query_params': {},
             '_target_object': None,
         }]
         self.assertEqual(connection._deleted_buckets, expected_cw)
 
-    def test_delete_hit_with_user_project(self):
+    def test_delete_hit(self):
         NAME = 'name'
-        USER_PROJECT = 'user-project-123'
         GET_BLOBS_RESP = {'items': []}
         connection = _Connection(GET_BLOBS_RESP)
         connection._delete_bucket = True
         client = _Client(connection)
-        bucket = self._make_one(
-            client=client, name=NAME, user_project=USER_PROJECT)
+        bucket = self._make_one(client=client, name=NAME)
         result = bucket.delete(force=True)
         self.assertIsNone(result)
         expected_cw = [{
             'method': 'DELETE',
             'path': bucket.path,
             '_target_object': None,
-            'query_params': {'userProject': USER_PROJECT},
         }]
         self.assertEqual(connection._deleted_buckets, expected_cw)
 
@@ -414,7 +361,6 @@ def test_delete_force_delete_blobs(self):
         expected_cw = [{
             'method': 'DELETE',
             'path': bucket.path,
-            'query_params': {},
             '_target_object': None,
         }]
         self.assertEqual(connection._deleted_buckets, expected_cw)
@@ -433,7 +379,6 @@ def test_delete_force_miss_blobs(self):
         expected_cw = [{
             'method': 'DELETE',
             'path': bucket.path,
-            'query_params': {},
             '_target_object': None,
         }]
         self.assertEqual(connection._deleted_buckets, expected_cw)
@@ -470,22 +415,18 @@ def test_delete_blob_miss(self):
         kw, = connection._requested
         self.assertEqual(kw['method'], 'DELETE')
         self.assertEqual(kw['path'], '/b/%s/o/%s' % (NAME, NONESUCH))
-        self.assertEqual(kw['query_params'], {})
 
-    def test_delete_blob_hit_with_user_project(self):
+    def test_delete_blob_hit(self):
         NAME = 'name'
         BLOB_NAME = 'blob-name'
-        USER_PROJECT = 'user-project-123'
         connection = _Connection({})
         client = _Client(connection)
-        bucket = self._make_one(
-            client=client, name=NAME, user_project=USER_PROJECT)
+        bucket = self._make_one(client=client, name=NAME)
         result = bucket.delete_blob(BLOB_NAME)
         self.assertIsNone(result)
         kw, = connection._requested
         self.assertEqual(kw['method'], 'DELETE')
         self.assertEqual(kw['path'], '/b/%s/o/%s' % (NAME, BLOB_NAME))
-        self.assertEqual(kw['query_params'], {'userProject': USER_PROJECT})
 
     def test_delete_blobs_empty(self):
         NAME = 'name'
@@ -495,20 +436,17 @@ def test_delete_blobs_empty(self):
         bucket.delete_blobs([])
         self.assertEqual(connection._requested, [])
 
-    def test_delete_blobs_hit_w_user_project(self):
+    def test_delete_blobs_hit(self):
         NAME = 'name'
         BLOB_NAME = 'blob-name'
-        USER_PROJECT = 'user-project-123'
         connection = _Connection({})
         client = _Client(connection)
-        bucket = self._make_one(
-            client=client, name=NAME, user_project=USER_PROJECT)
+        bucket = self._make_one(client=client, name=NAME)
         bucket.delete_blobs([BLOB_NAME])
         kw = connection._requested
         self.assertEqual(len(kw), 1)
         self.assertEqual(kw[0]['method'], 'DELETE')
         self.assertEqual(kw[0]['path'], '/b/%s/o/%s' % (NAME, BLOB_NAME))
-        self.assertEqual(kw[0]['query_params'], {'userProject': USER_PROJECT})
 
     def test_delete_blobs_miss_no_on_error(self):
         from google.cloud.exceptions import NotFound
@@ -566,7 +504,6 @@ class _Blob(object):
                                                      DEST, BLOB_NAME)
         self.assertEqual(kw['method'], 'POST')
         self.assertEqual(kw['path'], COPY_PATH)
-        self.assertEqual(kw['query_params'], {})
 
     def test_copy_blobs_preserve_acl(self):
         from google.cloud.storage.acl import ObjectACL
@@ -598,17 +535,14 @@ class _Blob(object):
         self.assertEqual(len(kw), 2)
         self.assertEqual(kw[0]['method'], 'POST')
         self.assertEqual(kw[0]['path'], COPY_PATH)
-        self.assertEqual(kw[0]['query_params'], {})
         self.assertEqual(kw[1]['method'], 'PATCH')
         self.assertEqual(kw[1]['path'], NEW_BLOB_PATH)
-        self.assertEqual(kw[1]['query_params'], {'projection': 'full'})
 
-    def test_copy_blobs_w_name_and_user_project(self):
+    def test_copy_blobs_w_name(self):
         SOURCE = 'source'
         DEST = 'dest'
         BLOB_NAME = 'blob-name'
         NEW_NAME = 'new_name'
-        USER_PROJECT = 'user-project-123'
 
         class _Blob(object):
             name = BLOB_NAME
@@ -616,8 +550,7 @@ class _Blob(object):
 
         connection = _Connection({})
         client = _Client(connection)
-        source = self._make_one(
-            client=client, name=SOURCE, user_project=USER_PROJECT)
+        source = self._make_one(client=client, name=SOURCE)
         dest = self._make_one(client=client, name=DEST)
         blob = _Blob()
         new_blob = source.copy_blob(blob, dest, NEW_NAME)
@@ -628,7 +561,6 @@ class _Blob(object):
                                                      DEST, NEW_NAME)
         self.assertEqual(kw['method'], 'POST')
         self.assertEqual(kw['path'], COPY_PATH)
-        self.assertEqual(kw['query_params'], {'userProject': USER_PROJECT})
 
     def test_rename_blob(self):
         BUCKET_NAME = 'BUCKET_NAME'
@@ -934,24 +866,6 @@ def test_versioning_enabled_setter(self):
         bucket.versioning_enabled = True
         self.assertTrue(bucket.versioning_enabled)
 
-    def test_requester_pays_getter_missing(self):
-        NAME = 'name'
-        bucket = self._make_one(name=NAME)
-        self.assertEqual(bucket.requester_pays, False)
-
-    def test_requester_pays_getter(self):
-        NAME = 'name'
-        before = {'billing': {'requesterPays': True}}
-        bucket = self._make_one(name=NAME, properties=before)
-        self.assertEqual(bucket.requester_pays, True)
-
-    def test_requester_pays_setter(self):
-        NAME = 'name'
-        bucket = self._make_one(name=NAME)
-        self.assertFalse(bucket.requester_pays)
-        bucket.requester_pays = True
-        self.assertTrue(bucket.requester_pays)
-
     def test_configure_website_defaults(self):
         NAME = 'name'
         UNSET = {'website': {'mainPageSuffix': None,
@@ -1020,40 +934,6 @@ def test_get_iam_policy(self):
         self.assertEqual(len(kw), 1)
         self.assertEqual(kw[0]['method'], 'GET')
         self.assertEqual(kw[0]['path'], '%s/iam' % (PATH,))
-        self.assertEqual(kw[0]['query_params'], {})
-
-    def test_get_iam_policy_w_user_project(self):
-        from google.cloud.iam import Policy
-
-        NAME = 'name'
-        USER_PROJECT = 'user-project-123'
-        PATH = '/b/%s' % (NAME,)
-        ETAG = 'DEADBEEF'
-        VERSION = 17
-        RETURNED = {
-            'resourceId': PATH,
-            'etag': ETAG,
-            'version': VERSION,
-            'bindings': [],
-        }
-        EXPECTED = {}
-        connection = _Connection(RETURNED)
-        client = _Client(connection, None)
-        bucket = self._make_one(
-            client=client, name=NAME, user_project=USER_PROJECT)
-
-        policy = bucket.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')
-        self.assertEqual(kw[0]['path'], '%s/iam' % (PATH,))
-        self.assertEqual(kw[0]['query_params'], {'userProject': USER_PROJECT})
 
     def test_set_iam_policy(self):
         import operator
@@ -1100,66 +980,6 @@ 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))
-        key = operator.itemgetter('role')
-        for found, expected in zip(
-            sorted(sent['bindings'], key=key),
-            sorted(BINDINGS, key=key)):
-            self.assertEqual(found['role'], expected['role'])
-            self.assertEqual(
-                sorted(found['members']), sorted(expected['members']))
-
-    def test_set_iam_policy_w_user_project(self):
-        import operator
-        from google.cloud.storage.iam import STORAGE_OWNER_ROLE
-        from google.cloud.storage.iam import STORAGE_EDITOR_ROLE
-        from google.cloud.storage.iam import STORAGE_VIEWER_ROLE
-        from google.cloud.iam import Policy
-
-        NAME = 'name'
-        USER_PROJECT = 'user-project-123'
-        PATH = '/b/%s' % (NAME,)
-        ETAG = 'DEADBEEF'
-        VERSION = 17
-        OWNER1 = 'user:phred@example.com'
-        OWNER2 = 'group:cloud-logs@google.com'
-        EDITOR1 = 'domain:google.com'
-        EDITOR2 = 'user:phred@example.com'
-        VIEWER1 = 'serviceAccount:1234-abcdef@service.example.com'
-        VIEWER2 = 'user:phred@example.com'
-        BINDINGS = [
-            {'role': STORAGE_OWNER_ROLE, 'members': [OWNER1, OWNER2]},
-            {'role': STORAGE_EDITOR_ROLE, 'members': [EDITOR1, EDITOR2]},
-            {'role': STORAGE_VIEWER_ROLE, 'members': [VIEWER1, VIEWER2]},
-        ]
-        RETURNED = {
-            'etag': ETAG,
-            'version': VERSION,
-            'bindings': BINDINGS,
-        }
-        policy = Policy()
-        for binding in BINDINGS:
-            policy[binding['role']] = binding['members']
-
-        connection = _Connection(RETURNED)
-        client = _Client(connection, None)
-        bucket = self._make_one(
-            client=client, name=NAME, user_project=USER_PROJECT)
-
-        returned = bucket.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})
         sent = kw[0]['data']
         self.assertEqual(sent['resourceId'], PATH)
         self.assertEqual(len(sent['bindings']), len(BINDINGS))
@@ -1199,38 +1019,6 @@ 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
-
-        NAME = 'name'
-        USER_PROJECT = 'user-project-123'
-        PATH = '/b/%s' % (NAME,)
-        PERMISSIONS = [
-            STORAGE_OBJECTS_LIST,
-            STORAGE_BUCKETS_GET,
-            STORAGE_BUCKETS_UPDATE,
-        ]
-        ALLOWED = PERMISSIONS[1:]
-        RETURNED = {'permissions': ALLOWED}
-        connection = _Connection(RETURNED)
-        client = _Client(connection, None)
-        bucket = self._make_one(
-            client=client, name=NAME, user_project=USER_PROJECT)
-
-        allowed = bucket.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_defaults(self):
         from google.cloud.storage.acl import _ACLEntity
 
diff --git a/storage/tests/unit/test_client.py b/storage/tests/unit/test_client.py
index 29545415a2209..9696d4e5fa515 100644
--- a/storage/tests/unit/test_client.py
+++ b/storage/tests/unit/test_client.py
@@ -155,22 +155,22 @@ def test_get_bucket_hit(self):
         CREDENTIALS = _make_credentials()
         client = self._make_one(project=PROJECT, credentials=CREDENTIALS)
 
-        BUCKET_NAME = 'bucket-name'
+        BLOB_NAME = 'blob-name'
         URI = '/'.join([
             client._connection.API_BASE_URL,
             'storage',
             client._connection.API_VERSION,
             'b',
-            '%s?projection=noAcl' % (BUCKET_NAME,),
+            '%s?projection=noAcl' % (BLOB_NAME,),
         ])
         http = client._http_internal = _Http(
             {'status': '200', 'content-type': 'application/json'},
-            '{{"name": "{0}"}}'.format(BUCKET_NAME).encode('utf-8'),
+            '{{"name": "{0}"}}'.format(BLOB_NAME).encode('utf-8'),
         )
 
-        bucket = client.get_bucket(BUCKET_NAME)
+        bucket = client.get_bucket(BLOB_NAME)
         self.assertIsInstance(bucket, Bucket)
-        self.assertEqual(bucket.name, BUCKET_NAME)
+        self.assertEqual(bucket.name, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'GET')
         self.assertEqual(http._called_with['uri'], URI)
 
@@ -203,34 +203,33 @@ def test_lookup_bucket_hit(self):
         CREDENTIALS = _make_credentials()
         client = self._make_one(project=PROJECT, credentials=CREDENTIALS)
 
-        BUCKET_NAME = 'bucket-name'
+        BLOB_NAME = 'blob-name'
         URI = '/'.join([
             client._connection.API_BASE_URL,
             'storage',
             client._connection.API_VERSION,
             'b',
-            '%s?projection=noAcl' % (BUCKET_NAME,),
+            '%s?projection=noAcl' % (BLOB_NAME,),
         ])
         http = client._http_internal = _Http(
             {'status': '200', 'content-type': 'application/json'},
-            '{{"name": "{0}"}}'.format(BUCKET_NAME).encode('utf-8'),
+            '{{"name": "{0}"}}'.format(BLOB_NAME).encode('utf-8'),
         )
 
-        bucket = client.lookup_bucket(BUCKET_NAME)
+        bucket = client.lookup_bucket(BLOB_NAME)
         self.assertIsInstance(bucket, Bucket)
-        self.assertEqual(bucket.name, BUCKET_NAME)
+        self.assertEqual(bucket.name, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'GET')
         self.assertEqual(http._called_with['uri'], URI)
 
     def test_create_bucket_conflict(self):
-        import json
         from google.cloud.exceptions import Conflict
 
         PROJECT = 'PROJECT'
         CREDENTIALS = _make_credentials()
         client = self._make_one(project=PROJECT, credentials=CREDENTIALS)
 
-        BUCKET_NAME = 'bucket-name'
+        BLOB_NAME = 'blob-name'
         URI = '/'.join([
             client._connection.API_BASE_URL,
             'storage',
@@ -242,21 +241,18 @@ def test_create_bucket_conflict(self):
             '{"error": {"message": "Conflict"}}',
         )
 
-        self.assertRaises(Conflict, client.create_bucket, BUCKET_NAME)
+        self.assertRaises(Conflict, client.create_bucket, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'POST')
         self.assertEqual(http._called_with['uri'], URI)
-        body = json.loads(http._called_with['body'])
-        self.assertEqual(body, {'name': BUCKET_NAME})
 
     def test_create_bucket_success(self):
-        import json
         from google.cloud.storage.bucket import Bucket
 
         PROJECT = 'PROJECT'
         CREDENTIALS = _make_credentials()
         client = self._make_one(project=PROJECT, credentials=CREDENTIALS)
 
-        BUCKET_NAME = 'bucket-name'
+        BLOB_NAME = 'blob-name'
         URI = '/'.join([
             client._connection.API_BASE_URL,
             'storage',
@@ -265,17 +261,14 @@ def test_create_bucket_success(self):
         ])
         http = client._http_internal = _Http(
             {'status': '200', 'content-type': 'application/json'},
-            '{{"name": "{0}"}}'.format(BUCKET_NAME).encode('utf-8'),
+            '{{"name": "{0}"}}'.format(BLOB_NAME).encode('utf-8'),
         )
 
-        bucket = client.create_bucket(BUCKET_NAME, requester_pays=True)
+        bucket = client.create_bucket(BLOB_NAME)
         self.assertIsInstance(bucket, Bucket)
-        self.assertEqual(bucket.name, BUCKET_NAME)
+        self.assertEqual(bucket.name, BLOB_NAME)
         self.assertEqual(http._called_with['method'], 'POST')
         self.assertEqual(http._called_with['uri'], URI)
-        body = json.loads(http._called_with['body'])
-        self.assertEqual(
-            body, {'name': BUCKET_NAME, 'billing': {'requesterPays': True}})
 
     def test_list_buckets_empty(self):
         from six.moves.urllib.parse import parse_qs
@@ -407,7 +400,7 @@ def test_page_non_empty_response(self):
         credentials = _make_credentials()
         client = self._make_one(project=project, credentials=credentials)
 
-        blob_name = 'bucket-name'
+        blob_name = 'blob-name'
         response = {'items': [{'name': blob_name}]}
 
         def dummy_response():