diff --git a/gcloud/bigtable/client.py b/gcloud/bigtable/client.py
index 2ec8f6e89bd2..1405928df98a 100644
--- a/gcloud/bigtable/client.py
+++ b/gcloud/bigtable/client.py
@@ -40,8 +40,8 @@
 from gcloud.bigtable._generated_v2 import (
     bigtable_pb2 as data_v2_pb2)
 
-from gcloud.bigtable._generated import (
-    operations_grpc_pb2 as operations_grpc_v1_pb2)
+from gcloud.bigtable._generated_v2 import (
+    operations_grpc_pb2 as operations_grpc_v2_pb2)
 
 from gcloud.bigtable.instance import Instance
 from gcloud.client import _ClientFactoryMixin
@@ -51,14 +51,14 @@
 
 TABLE_STUB_FACTORY_V2 = (
     table_admin_v2_pb2.beta_create_BigtableTableAdmin_stub)
-TABLE_ADMIN_HOST_V2 = 'bigtabletableadmin.googleapis.com'
+TABLE_ADMIN_HOST_V2 = 'bigtableadmin.googleapis.com'
 """Table Admin API request host."""
 TABLE_ADMIN_PORT_V2 = 443
 """Table Admin API request port."""
 
 INSTANCE_STUB_FACTORY_V2 = (
     instance_admin_v2_pb2.beta_create_BigtableInstanceAdmin_stub)
-INSTANCE_ADMIN_HOST_V2 = 'bigtableclusteradmin.googleapis.com'
+INSTANCE_ADMIN_HOST_V2 = 'bigtableadmin.googleapis.com'
 """Cluster Admin API request host."""
 INSTANCE_ADMIN_PORT_V2 = 443
 """Cluster Admin API request port."""
@@ -69,7 +69,7 @@
 DATA_API_PORT_V2 = 443
 """Data API request port."""
 
-OPERATIONS_STUB_FACTORY_V2 = operations_grpc_v1_pb2.beta_create_Operations_stub
+OPERATIONS_STUB_FACTORY_V2 = operations_grpc_v2_pb2.beta_create_Operations_stub
 OPERATIONS_API_HOST_V2 = INSTANCE_ADMIN_HOST_V2
 OPERATIONS_API_PORT_V2 = INSTANCE_ADMIN_PORT_V2
 
@@ -98,14 +98,14 @@ class Client(_ClientFactoryMixin, _ClientProjectMixin):
 
     :type project: :class:`str` or :func:`unicode <unicode>`
     :param project: (Optional) The ID of the project which owns the
-                    clusters, tables and data. If not provided, will
+                    instances, tables and data. If not provided, will
                     attempt to determine from the environment.
 
     :type credentials:
         :class:`OAuth2Credentials <oauth2client.client.OAuth2Credentials>` or
         :data:`NoneType <types.NoneType>`
     :param credentials: (Optional) The OAuth2 Credentials to use for this
-                        cluster. If not provided, defaults to the Google
+                        client. If not provided, defaults to the Google
                         Application Default Credentials.
 
     :type read_only: bool
@@ -162,7 +162,7 @@ def __init__(self, project=None, credentials=None,
 
         # These will be set in start().
         self._data_stub_internal = None
-        self._cluster_stub_internal = None
+        self._instance_stub_internal = None
         self._operations_stub_internal = None
         self._table_stub_internal = None
 
@@ -229,7 +229,7 @@ def _data_stub(self):
         return self._data_stub_internal
 
     @property
-    def _cluster_stub(self):
+    def _instance_stub(self):
         """Getter for the gRPC stub used for the Instance Admin API.
 
         :rtype: :class:`grpc.beta._stub._AutoIntermediary`
@@ -240,9 +240,9 @@ def _cluster_stub(self):
         """
         if not self._admin:
             raise ValueError('Client is not an admin client.')
-        if self._cluster_stub_internal is None:
+        if self._instance_stub_internal is None:
             raise ValueError('Client has not been started.')
-        return self._cluster_stub_internal
+        return self._instance_stub_internal
 
     @property
     def _operations_stub(self):
@@ -285,7 +285,7 @@ def _make_data_stub(self):
         return _make_stub(self, DATA_STUB_FACTORY_V2,
                           DATA_API_HOST_V2, DATA_API_PORT_V2)
 
-    def _make_cluster_stub(self):
+    def _make_instance_stub(self):
         """Creates gRPC stub to make requests to the Instance Admin API.
 
         :rtype: :class:`grpc.beta._stub._AutoIntermediary`
@@ -340,11 +340,11 @@ def start(self):
         self._data_stub_internal = self._make_data_stub()
         self._data_stub_internal.__enter__()
         if self._admin:
-            self._cluster_stub_internal = self._make_cluster_stub()
+            self._instance_stub_internal = self._make_instance_stub()
             self._operations_stub_internal = self._make_operations_stub()
             self._table_stub_internal = self._make_table_stub()
 
-            self._cluster_stub_internal.__enter__()
+            self._instance_stub_internal.__enter__()
             self._operations_stub_internal.__enter__()
             self._table_stub_internal.__enter__()
 
@@ -362,12 +362,12 @@ def stop(self):
         # traceback to __exit__.
         self._data_stub_internal.__exit__(None, None, None)
         if self._admin:
-            self._cluster_stub_internal.__exit__(None, None, None)
+            self._instance_stub_internal.__exit__(None, None, None)
             self._operations_stub_internal.__exit__(None, None, None)
             self._table_stub_internal.__exit__(None, None, None)
 
         self._data_stub_internal = None
-        self._cluster_stub_internal = None
+        self._instance_stub_internal = None
         self._operations_stub_internal = None
         self._table_stub_internal = None
 
@@ -392,13 +392,31 @@ def instance(self, instance_id, display_name=None):
         """
         return Instance(instance_id, self, display_name=display_name)
 
+    def list_instances(self):
+        """List instances owned by the project.
+
+        :rtype: tuple
+        :returns: A pair of results, the first is a list of
+                  :class:`.Instance` objects returned and the second is a
+                  list of strings (the failed locations in the request).
+        """
+        request_pb = instance_admin_v2_pb2.ListInstancesRequest(
+            parent=self.project_name)
+
+        response = self._instance_stub.ListInstances(
+            request_pb, self.timeout_seconds)
+
+        instances = [Instance.from_pb(instance_pb, self)
+                     for instance_pb in response.instances]
+        return instances, response.failed_locations
+
 
 class _MetadataPlugin(object):
     """Callable class to transform metadata for gRPC requests.
 
     :type client: :class:`.client.Client`
-    :param client: The client that owns the cluster. Provides authorization and
-                   user agent.
+    :param client: The client that owns the instance.
+                   Provides authorization and user agent.
     """
 
     def __init__(self, client):
@@ -421,8 +439,8 @@ def _make_stub(client, stub_factory, host, port):
     Uses / depends on the beta implementation of gRPC.
 
     :type client: :class:`.client.Client`
-    :param client: The client that owns the cluster. Provides authorization and
-                   user agent.
+    :param client: The client that owns the instance.
+                   Provides authorization and user agent.
 
     :type stub_factory: callable
     :param stub_factory: A factory which will create a gRPC stub for
diff --git a/gcloud/bigtable/cluster.py b/gcloud/bigtable/cluster.py
index bb5cfb349498..7867cff82bc7 100644
--- a/gcloud/bigtable/cluster.py
+++ b/gcloud/bigtable/cluster.py
@@ -210,7 +210,7 @@ def _update_from_pb(self, cluster_pb):
     def from_pb(cls, cluster_pb, instance):
         """Creates a cluster instance from a protobuf.
 
-        :type cluster_pb: :class:`bigtable_cluster_data_pb2.Cluster`
+        :type cluster_pb: :class:`instance_pb2.Cluster`
         :param cluster_pb: A cluster protobuf object.
 
         :type instance: :class:`.instance.Instance>`
@@ -288,8 +288,8 @@ def __ne__(self, other):
     def reload(self):
         """Reload the metadata for this cluster."""
         request_pb = messages_v2_pb2.GetClusterRequest(name=self.name)
-        # We expect a `._generated.bigtable_cluster_data_pb2.Cluster`.
-        cluster_pb = self._instance._client._cluster_stub.GetCluster(
+        # We expect a `._generated_v2.instance_pb2.Cluster`.
+        cluster_pb = self._instance._client._instance_stub.GetCluster(
             request_pb, self._instance._client.timeout_seconds)
 
         # NOTE: _update_from_pb does not check that the project, instance and
@@ -318,7 +318,7 @@ def create(self):
         """
         request_pb = _prepare_create_request(self)
         # We expect a `google.longrunning.operations_pb2.Operation`.
-        operation_pb = self._instance._client._cluster_stub.CreateCluster(
+        operation_pb = self._instance._client._instance_stub.CreateCluster(
             request_pb, self._instance._client.timeout_seconds)
 
         op_id = _process_operation(operation_pb)
@@ -346,8 +346,8 @@ def update(self):
             name=self.name,
             serve_nodes=self.serve_nodes,
         )
-        # Ignore expected `._generated.bigtable_cluster_data_pb2.Cluster`.
-        operation_pb = self._instance._client._cluster_stub.UpdateCluster(
+        # Ignore expected `._generated_v2.instance_pb2.Cluster`.
+        operation_pb = self._instance._client._instance_stub.UpdateCluster(
             request_pb, self._instance._client.timeout_seconds)
 
         op_id = _process_operation(operation_pb)
@@ -380,5 +380,5 @@ def delete(self):
         """
         request_pb = messages_v2_pb2.DeleteClusterRequest(name=self.name)
         # We expect a `google.protobuf.empty_pb2.Empty`
-        self._instance._client._cluster_stub.DeleteCluster(
+        self._instance._client._instance_stub.DeleteCluster(
             request_pb, self._instance._client.timeout_seconds)
diff --git a/gcloud/bigtable/row.py b/gcloud/bigtable/row.py
index aae048b0c7d6..07cf9e1abec4 100644
--- a/gcloud/bigtable/row.py
+++ b/gcloud/bigtable/row.py
@@ -854,7 +854,7 @@ def _parse_rmw_row_response(row_response):
 def _parse_family_pb(family_pb):
     """Parses a Family protobuf into a dictionary.
 
-    :type family_pb: :class:`._generated.bigtable_data_pb2.Family`
+    :type family_pb: :class:`._generated_v2.data_pb2.Family`
     :param family_pb: A protobuf
 
     :rtype: tuple
diff --git a/gcloud/bigtable/row_data.py b/gcloud/bigtable/row_data.py
index e353b8735ba9..3f4490097e68 100644
--- a/gcloud/bigtable/row_data.py
+++ b/gcloud/bigtable/row_data.py
@@ -44,7 +44,7 @@ def __init__(self, value, timestamp, labels=()):
     def from_pb(cls, cell_pb):
         """Create a new cell from a Cell protobuf.
 
-        :type cell_pb: :class:`._generated.bigtable_data_pb2.Cell`
+        :type cell_pb: :class:`._generated_v2.data_pb2.Cell`
         :param cell_pb: The protobuf to convert.
 
         :rtype: :class:`Cell`
diff --git a/gcloud/bigtable/table.py b/gcloud/bigtable/table.py
index 6c2cfd82fac9..c0a3b6e335c0 100644
--- a/gcloud/bigtable/table.py
+++ b/gcloud/bigtable/table.py
@@ -141,7 +141,7 @@ def create(self, initial_split_keys=None):
 
         .. note::
 
-            Though a :class:`._generated.bigtable_table_data_pb2.Table` is also
+            Though a :class:`._generated_v2.table_pb2.Table` is also
             allowed (as the ``table`` property) in a create table request, we
             do not support it in this method. As mentioned in the
             :class:`Table` docstring, the name is the only useful property in
@@ -150,7 +150,7 @@ def create(self, initial_split_keys=None):
         .. note::
 
             A create request returns a
-            :class:`._generated.bigtable_table_data_pb2.Table` but we don't use
+            :class:`._generated_v2.table_pb2.Table` but we don't use
             this response. The proto definition allows for the inclusion of a
             ``current_operation`` in the response, but it does not appear that
             the Cloud Bigtable API returns any operation.
@@ -174,7 +174,7 @@ def create(self, initial_split_keys=None):
             table_id=self.table_id,
         )
         client = self._instance._client
-        # We expect a `._generated.bigtable_table_data_pb2.Table`
+        # We expect a `._generated_v2.table_pb2.Table`
         client._table_stub.CreateTable(request_pb, client.timeout_seconds)
 
     def delete(self):
@@ -199,7 +199,7 @@ def list_column_families(self):
         request_pb = table_admin_messages_v2_pb2.GetTableRequest(
             name=self.name)
         client = self._instance._client
-        # We expect a `._generated.bigtable_table_data_pb2.Table`
+        # We expect a `._generated_v2.table_pb2.Table`
         table_pb = client._table_stub.GetTable(request_pb,
                                                client.timeout_seconds)
 
diff --git a/gcloud/bigtable/test_client.py b/gcloud/bigtable/test_client.py
index eeff14a5aab4..414e1ae5e171 100644
--- a/gcloud/bigtable/test_client.py
+++ b/gcloud/bigtable/test_client.py
@@ -18,6 +18,12 @@
 
 class TestClient(unittest2.TestCase):
 
+    PROJECT = 'PROJECT'
+    INSTANCE_ID = 'instance-id'
+    DISPLAY_NAME = 'display-name'
+    TIMEOUT_SECONDS = 80
+    USER_AGENT = 'you-sir-age-int'
+
     def _getTargetClass(self):
         from gcloud.bigtable.client import Client
         return Client
@@ -33,8 +39,7 @@ def _constructor_test_helper(self, expected_scopes, creds,
 
         user_agent = user_agent or MUT.DEFAULT_USER_AGENT
         timeout_seconds = timeout_seconds or MUT.DEFAULT_TIMEOUT_SECONDS
-        PROJECT = 'PROJECT'
-        client = self._makeOne(project=PROJECT, credentials=creds,
+        client = self._makeOne(project=self.PROJECT, credentials=creds,
                                read_only=read_only, admin=admin,
                                user_agent=user_agent,
                                timeout_seconds=timeout_seconds)
@@ -44,12 +49,12 @@ def _constructor_test_helper(self, expected_scopes, creds,
         if expected_scopes is not None:
             self.assertEqual(client._credentials.scopes, expected_scopes)
 
-        self.assertEqual(client.project, PROJECT)
+        self.assertEqual(client.project, self.PROJECT)
         self.assertEqual(client.timeout_seconds, timeout_seconds)
         self.assertEqual(client.user_agent, user_agent)
         # Check stubs are set (but null)
         self.assertEqual(client._data_stub_internal, None)
-        self.assertEqual(client._cluster_stub_internal, None)
+        self.assertEqual(client._instance_stub_internal, None)
         self.assertEqual(client._operations_stub_internal, None)
         self.assertEqual(client._table_stub_internal, None)
 
@@ -63,13 +68,13 @@ def test_constructor_default_scopes(self):
     def test_constructor_custom_user_agent_and_timeout(self):
         from gcloud.bigtable import client as MUT
 
-        timeout_seconds = 1337
-        user_agent = 'custom-application'
+        CUSTOM_TIMEOUT_SECONDS = 1337
+        CUSTOM_USER_AGENT = 'custom-application'
         expected_scopes = [MUT.DATA_SCOPE]
         creds = _Credentials()
         self._constructor_test_helper(expected_scopes, creds,
-                                      user_agent=user_agent,
-                                      timeout_seconds=timeout_seconds)
+                                      user_agent=CUSTOM_USER_AGENT,
+                                      timeout_seconds=CUSTOM_TIMEOUT_SECONDS)
 
     def test_constructor_with_admin(self):
         from gcloud.bigtable import client as MUT
@@ -112,8 +117,7 @@ def test_constructor_credentials_wo_create_scoped(self):
 
     def _context_manager_helper(self):
         credentials = _Credentials()
-        project = 'PROJECT'
-        client = self._makeOne(project=project, credentials=credentials)
+        client = self._makeOne(project=self.PROJECT, credentials=credentials)
 
         def mock_start():
             client._data_stub_internal = object()
@@ -151,17 +155,17 @@ class DummyException(Exception):
 
     def _copy_test_helper(self, read_only=False, admin=False):
         credentials = _Credentials('value')
-        project = 'PROJECT'
-        timeout_seconds = 123
-        user_agent = 'you-sir-age-int'
-        client = self._makeOne(project=project, credentials=credentials,
-                               read_only=read_only, admin=admin,
-                               timeout_seconds=timeout_seconds,
-                               user_agent=user_agent)
+        client = self._makeOne(
+            project=self.PROJECT,
+            credentials=credentials,
+            read_only=read_only,
+            admin=admin,
+            timeout_seconds=self.TIMEOUT_SECONDS,
+            user_agent=self.USER_AGENT)
         # Put some fake stubs in place so that we can verify they
         # don't get copied.
         client._data_stub_internal = object()
-        client._cluster_stub_internal = object()
+        client._instance_stub_internal = object()
         client._operations_stub_internal = object()
         client._table_stub_internal = object()
 
@@ -173,7 +177,7 @@ def _copy_test_helper(self, read_only=False, admin=False):
         self.assertEqual(new_client.timeout_seconds, client.timeout_seconds)
         # Make sure stubs are not preserved.
         self.assertEqual(new_client._data_stub_internal, None)
-        self.assertEqual(new_client._cluster_stub_internal, None)
+        self.assertEqual(new_client._instance_stub_internal, None)
         self.assertEqual(new_client._operations_stub_internal, None)
         self.assertEqual(new_client._table_stub_internal, None)
 
@@ -213,29 +217,30 @@ def test_data_stub_failure(self):
         with self.assertRaises(ValueError):
             getattr(client, '_data_stub')
 
-    def test_cluster_stub_getter(self):
+    def test_instance_stub_getter(self):
         credentials = _Credentials()
         project = 'PROJECT'
         client = self._makeOne(project=project, credentials=credentials,
                                admin=True)
-        client._cluster_stub_internal = object()
-        self.assertTrue(client._cluster_stub is client._cluster_stub_internal)
+        client._instance_stub_internal = object()
+        self.assertTrue(
+            client._instance_stub is client._instance_stub_internal)
 
-    def test_cluster_stub_non_admin_failure(self):
+    def test_instance_stub_non_admin_failure(self):
         credentials = _Credentials()
         project = 'PROJECT'
         client = self._makeOne(project=project, credentials=credentials,
                                admin=False)
         with self.assertRaises(ValueError):
-            getattr(client, '_cluster_stub')
+            getattr(client, '_instance_stub')
 
-    def test_cluster_stub_unset_failure(self):
+    def test_instance_stub_unset_failure(self):
         credentials = _Credentials()
         project = 'PROJECT'
         client = self._makeOne(project=project, credentials=credentials,
                                admin=True)
         with self.assertRaises(ValueError):
-            getattr(client, '_cluster_stub')
+            getattr(client, '_instance_stub')
 
     def test_operations_stub_getter(self):
         credentials = _Credentials()
@@ -317,7 +322,7 @@ def mock_make_stub(*args):
             ),
         ])
 
-    def test__make_cluster_stub(self):
+    def test__make_instance_stub(self):
         from gcloud._testing import _Monkey
         from gcloud.bigtable import client as MUT
         from gcloud.bigtable.client import INSTANCE_ADMIN_HOST_V2
@@ -336,7 +341,7 @@ def mock_make_stub(*args):
             return fake_stub
 
         with _Monkey(MUT, _make_stub=mock_make_stub):
-            result = client._make_cluster_stub()
+            result = client._make_instance_stub()
 
         self.assertTrue(result is fake_stub)
         self.assertEqual(make_stub_args, [
@@ -443,13 +448,13 @@ def mock_make_stub(*args):
 
         self.assertTrue(client._data_stub_internal is stub)
         if admin:
-            self.assertTrue(client._cluster_stub_internal is stub)
+            self.assertTrue(client._instance_stub_internal is stub)
             self.assertTrue(client._operations_stub_internal is stub)
             self.assertTrue(client._table_stub_internal is stub)
             self.assertEqual(stub._entered, 4)
             self.assertEqual(len(make_stub_args), 4)
         else:
-            self.assertTrue(client._cluster_stub_internal is None)
+            self.assertTrue(client._instance_stub_internal is None)
             self.assertTrue(client._operations_stub_internal is None)
             self.assertTrue(client._table_stub_internal is None)
             self.assertEqual(stub._entered, 1)
@@ -484,12 +489,12 @@ def _stop_method_helper(self, admin):
         stub1 = _FakeStub()
         stub2 = _FakeStub()
         client._data_stub_internal = stub1
-        client._cluster_stub_internal = stub2
+        client._instance_stub_internal = stub2
         client._operations_stub_internal = stub2
         client._table_stub_internal = stub2
         client.stop()
         self.assertTrue(client._data_stub_internal is None)
-        self.assertTrue(client._cluster_stub_internal is None)
+        self.assertTrue(client._instance_stub_internal is None)
         self.assertTrue(client._operations_stub_internal is None)
         self.assertTrue(client._table_stub_internal is None)
         self.assertEqual(stub1._entered, 0)
@@ -516,10 +521,10 @@ def test_stop_while_stopped(self):
         # This is a bit hacky. We set the cluster stub protected value
         # since it isn't used in is_started() and make sure that stop
         # doesn't reset this value to None.
-        client._cluster_stub_internal = cluster_stub = object()
+        client._instance_stub_internal = instance_stub = object()
         client.stop()
         # Make sure the cluster stub did not change.
-        self.assertEqual(client._cluster_stub_internal, cluster_stub)
+        self.assertEqual(client._instance_stub_internal, instance_stub)
 
     def test_instance_factory(self):
         from gcloud.bigtable.instance import Instance
@@ -537,6 +542,71 @@ def test_instance_factory(self):
         self.assertEqual(instance.display_name, DISPLAY_NAME)
         self.assertTrue(instance._client is client)
 
+    def test_list_instances(self):
+        from gcloud.bigtable._generated_v2 import (
+            instance_pb2 as data_v2_pb2)
+        from gcloud.bigtable._generated_v2 import (
+            bigtable_instance_admin_pb2 as messages_v2_pb2)
+        from gcloud.bigtable._testing import _FakeStub
+
+        FAILED_LOCATION = 'FAILED'
+        INSTANCE_ID1 = 'instance-id1'
+        INSTANCE_ID2 = 'instance-id2'
+        INSTANCE_NAME1 = (
+            'projects/' + self.PROJECT + '/instances/' + INSTANCE_ID1)
+        INSTANCE_NAME2 = (
+            'projects/' + self.PROJECT + '/instances/' + INSTANCE_ID2)
+
+        credentials = _Credentials()
+        client = self._makeOne(
+            project=self.PROJECT,
+            credentials=credentials,
+            admin=True,
+            timeout_seconds=self.TIMEOUT_SECONDS,
+        )
+
+        # Create request_pb
+        request_pb = messages_v2_pb2.ListInstancesRequest(
+            parent='projects/' + self.PROJECT,
+        )
+
+        # Create response_pb
+        response_pb = messages_v2_pb2.ListInstancesResponse(
+            failed_locations=[
+                FAILED_LOCATION,
+            ],
+            instances=[
+                data_v2_pb2.Instance(
+                    name=INSTANCE_NAME1,
+                    display_name=INSTANCE_NAME1,
+                ),
+                data_v2_pb2.Instance(
+                    name=INSTANCE_NAME2,
+                    display_name=INSTANCE_NAME2,
+                ),
+            ],
+        )
+
+        # Patch the stub used by the API method.
+        client._instance_stub_internal = stub = _FakeStub(response_pb)
+
+        # Create expected_result.
+        failed_locations = [FAILED_LOCATION]
+        instances = [
+            client.instance(INSTANCE_ID1),
+            client.instance(INSTANCE_ID2),
+        ]
+        expected_result = (instances, failed_locations)
+
+        # Perform the method and check the result.
+        result = client.list_instances()
+        self.assertEqual(result, expected_result)
+        self.assertEqual(stub.method_calls, [(
+            'ListInstances',
+            (request_pb, self.TIMEOUT_SECONDS),
+            {},
+        )])
+
 
 class Test_MetadataPlugin(unittest2.TestCase):
 
@@ -550,15 +620,15 @@ def _makeOne(self, *args, **kwargs):
     def test_constructor(self):
         from gcloud.bigtable.client import Client
         from gcloud.bigtable.client import DATA_SCOPE
+        PROJECT = 'PROJECT'
+        USER_AGENT = 'USER_AGENT'
 
         credentials = _Credentials()
-        project = 'PROJECT'
-        user_agent = 'USER_AGENT'
-        client = Client(project=project, credentials=credentials,
-                        user_agent=user_agent)
+        client = Client(project=PROJECT, credentials=credentials,
+                        user_agent=USER_AGENT)
         transformer = self._makeOne(client)
         self.assertTrue(transformer._credentials is credentials)
-        self.assertEqual(transformer._user_agent, user_agent)
+        self.assertEqual(transformer._user_agent, USER_AGENT)
         self.assertEqual(credentials.scopes, [DATA_SCOPE])
 
     def test___call__(self):
diff --git a/gcloud/bigtable/test_cluster.py b/gcloud/bigtable/test_cluster.py
index a1a43b5533cc..4f8da614f439 100644
--- a/gcloud/bigtable/test_cluster.py
+++ b/gcloud/bigtable/test_cluster.py
@@ -321,7 +321,7 @@ def test_reload(self):
         )
 
         # Patch the stub used by the API method.
-        client._cluster_stub = stub = _FakeStub(response_pb)
+        client._instance_stub = stub = _FakeStub(response_pb)
 
         # Create expected_result.
         expected_result = None  # reload() has no return value.
@@ -364,7 +364,7 @@ def test_create(self):
         response_pb = operations_pb2.Operation(name=OP_NAME)
 
         # Patch the stub used by the API method.
-        client._cluster_stub = stub = _FakeStub(response_pb)
+        client._instance_stub = stub = _FakeStub(response_pb)
 
         # Create expected_result.
         expected_result = MUT.Operation('create', OP_ID, cluster=cluster)
@@ -419,7 +419,7 @@ def test_update(self):
         response_pb = operations_pb2.Operation()
 
         # Patch the stub used by the API method.
-        client._cluster_stub = stub = _FakeStub(response_pb)
+        client._instance_stub = stub = _FakeStub(response_pb)
 
         # Create expected_result.
         OP_ID = 5678
@@ -459,7 +459,7 @@ def test_delete(self):
         response_pb = empty_pb2.Empty()
 
         # Patch the stub used by the API method.
-        client._cluster_stub = stub = _FakeStub(response_pb)
+        client._instance_stub = stub = _FakeStub(response_pb)
 
         # Create expected_result.
         expected_result = None  # delete() has no return value.
diff --git a/gcloud/bigtable/test_row_data.py b/gcloud/bigtable/test_row_data.py
index 6fae4d18c40b..2162212e7fdd 100644
--- a/gcloud/bigtable/test_row_data.py
+++ b/gcloud/bigtable/test_row_data.py
@@ -28,19 +28,19 @@ def _makeOne(self, *args, **kwargs):
     def _from_pb_test_helper(self, labels=None):
         import datetime
         from gcloud._helpers import _EPOCH
-        from gcloud.bigtable._generated import (
-            bigtable_data_pb2 as data_v1_pb2)
+        from gcloud.bigtable._generated_v2 import (
+            data_pb2 as data_v2_pb2)
 
         timestamp_micros = 18738724000  # Make sure millis granularity
         timestamp = _EPOCH + datetime.timedelta(microseconds=timestamp_micros)
         value = b'value-bytes'
 
         if labels is None:
-            cell_pb = data_v1_pb2.Cell(
+            cell_pb = data_v2_pb2.Cell(
                 value=value, timestamp_micros=timestamp_micros)
             cell_expected = self._makeOne(value, timestamp)
         else:
-            cell_pb = data_v1_pb2.Cell(
+            cell_pb = data_v2_pb2.Cell(
                 value=value, timestamp_micros=timestamp_micros, labels=labels)
             cell_expected = self._makeOne(value, timestamp, labels=labels)