From 97bf3d2d88f8a4d4afb69e212dd1a47ddee9e31a Mon Sep 17 00:00:00 2001 From: Sangram Date: Wed, 22 May 2019 15:39:35 +0530 Subject: [PATCH 1/2] Add transport as wrapper for channel --- bigtable/google/cloud/bigtable/client.py | 83 +++++++++- bigtable/tests/unit/test_client.py | 189 ++++++++++++++++++++++- 2 files changed, 264 insertions(+), 8 deletions(-) diff --git a/bigtable/google/cloud/bigtable/client.py b/bigtable/google/cloud/bigtable/client.py index f9a625b15843..42cf37235d24 100644 --- a/bigtable/google/cloud/bigtable/client.py +++ b/bigtable/google/cloud/bigtable/client.py @@ -35,6 +35,11 @@ from google.cloud import bigtable_v2 from google.cloud import bigtable_admin_v2 +from google.cloud.bigtable_v2.gapic.transports import bigtable_grpc_transport +from google.cloud.bigtable_admin_v2.gapic.transports import ( + bigtable_table_admin_grpc_transport, + bigtable_instance_admin_grpc_transport, +) from google.cloud.bigtable import __version__ from google.cloud.bigtable.instance import Instance @@ -61,11 +66,14 @@ def _create_gapic_client(client_class): - def inner(self): + def inner(self, transport=None): if self._emulator_host is None: - return client_class( - credentials=self._credentials, client_info=self._client_info - ) + if transport is not None: + return client_class(transport=transport, client_info=self._client_info) + else: + return client_class( + credentials=self._credentials, client_info=self._client_info + ) else: return client_class( channel=self._emulator_channel, client_info=self._client_info @@ -74,6 +82,18 @@ def inner(self): return inner +def transport(channel=None): + def inner(credentials=None, default_class=None): + if channel is not None: + return default_class(channel=channel) + elif credentials is not None: + return default_class(credentials=credentials) + else: + return None + + return inner + + class Client(ClientWithProject): """Client for interacting with Google Cloud Bigtable API. @@ -122,6 +142,8 @@ class Client(ClientWithProject): _table_data_client = None _table_admin_client = None _instance_admin_client = None + _admin_transport = None + _data_transport = None def __init__( self, @@ -140,6 +162,7 @@ def __init__( # NOTE: We set the scopes **before** calling the parent constructor. # It **may** use those scopes in ``with_scopes_if_required``. self._read_only = bool(read_only) + self._credentials = credentials self._admin = bool(admin) self._client_info = client_info self._emulator_host = os.getenv(BIGTABLE_EMULATOR) @@ -213,8 +236,15 @@ def table_data_client(self): :returns: A BigtableClient object. """ if self._table_data_client is None: + if self._data_transport is not None: + transport = self.data_transport( + default_class=bigtable_grpc_transport.BigtableGrpcTransport + ) + else: + transport = None + self._table_data_client = _create_gapic_client(bigtable_v2.BigtableClient)( - self + self, transport=transport ) return self._table_data_client @@ -237,9 +267,15 @@ def table_admin_client(self): if self._table_admin_client is None: if not self._admin: raise ValueError("Client is not an admin client.") + if self._admin_transport is not None: + transport = self.admin_transport( + default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport + ) + else: + transport = None self._table_admin_client = _create_gapic_client( bigtable_admin_v2.BigtableTableAdminClient - )(self) + )(self, transport=transport) return self._table_admin_client @property @@ -261,11 +297,44 @@ def instance_admin_client(self): if self._instance_admin_client is None: if not self._admin: raise ValueError("Client is not an admin client.") + if self._admin_transport is not None: + transport = self.admin_transport( + default_class=bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport + ) + else: + transport = None self._instance_admin_client = _create_gapic_client( bigtable_admin_v2.BigtableInstanceAdminClient - )(self) + )(self, transport=transport) return self._instance_admin_client + @property + def data_transport(self): + return self._data_transport + + @data_transport.setter + def data_transport(self, channel=None): + if self._data_transport is None: + if channel is not None: + self._data_transport = transport(channel=channel) + elif self._credentials is not None: + self._data_transport = transport() + + @property + def admin_transport(self): + return self._admin_transport + + @admin_transport.setter + def admin_transport(self, channel=None): + + if self._admin_transport is None: + if not self._admin: + raise ValueError("Client is not an admin client.") + if channel is not None: + self._admin_transport = transport(channel=channel) + elif self._credentials is not None: + self._admin_transport = transport() + def instance(self, instance_id, display_name=None, instance_type=None, labels=None): """Factory to create a instance associated with this client. diff --git a/bigtable/tests/unit/test_client.py b/bigtable/tests/unit/test_client.py index 05a017d898af..d6f83cf41f3b 100644 --- a/bigtable/tests/unit/test_client.py +++ b/bigtable/tests/unit/test_client.py @@ -210,6 +210,79 @@ def test_table_data_client_not_initialized_w_client_info(self): self.assertIs(table_data_client._client_info, client_info) self.assertIs(client._table_data_client, table_data_client) + def test_data_transport_not_initialized_w_admin_flag(self): + from google.cloud.bigtable_v2.gapic.transports import bigtable_grpc_transport + + channel = mock.Mock() + + client = self._make_one(project=self.PROJECT, admin=True) + + client.data_transport = channel + self.assertTrue(callable(client.data_transport)) + data_transport = client.data_transport( + default_class=bigtable_grpc_transport.BigtableGrpcTransport + ) + self.assertIsInstance( + data_transport, bigtable_grpc_transport.BigtableGrpcTransport + ) + + self.assertIsInstance( + client._data_transport( + default_class=bigtable_grpc_transport.BigtableGrpcTransport + ), + bigtable_grpc_transport.BigtableGrpcTransport, + ) + + def test_table_data_client_not_initialized_w_data_transport_w_channel(self): + from google.cloud.bigtable.client import _CLIENT_INFO + from google.cloud.bigtable_v2 import BigtableClient + from google.cloud.bigtable_v2.gapic.transports import bigtable_grpc_transport + + client = self._make_one(project=self.PROJECT, admin=True) + + channel = mock.Mock() + + client.data_transport = channel + + self.assertTrue(callable(client.data_transport)) + data_transport = client.data_transport( + default_class=bigtable_grpc_transport.BigtableGrpcTransport + ) + + table_data_client = client.table_data_client + self.assertIsInstance( + data_transport, bigtable_grpc_transport.BigtableGrpcTransport + ) + + self.assertIsInstance( + table_data_client.transport, bigtable_grpc_transport.BigtableGrpcTransport + ) + + self.assertIsInstance(table_data_client, BigtableClient) + self.assertIs(table_data_client._client_info, _CLIENT_INFO) + self.assertIs(client._table_data_client, table_data_client) + + def test_table_data_client_not_initialized_w_data_transport_w_credentials(self): + from google.cloud.bigtable.client import _CLIENT_INFO + from google.cloud.bigtable_v2 import BigtableClient + + credentials = _make_credentials() + client = self._make_one( + project=self.PROJECT, credentials=credentials, admin=True + ) + + client.data_transport = None + data_transport = client.data_transport + self.assertTrue(callable(data_transport)) + + self.assertIsNot(client._credentials, None) + + table_data_client = client.table_data_client + + self.assertIsInstance(table_data_client, BigtableClient) + self.assertIs(table_data_client._client_info, _CLIENT_INFO) + self.assertIs(client._table_data_client, table_data_client) + def test_table_data_client_initialized(self): credentials = _make_credentials() client = self._make_one( @@ -226,7 +299,66 @@ def test_table_admin_client_not_initialized_no_admin_flag(self): with self.assertRaises(ValueError): client.table_admin_client() - def test_table_admin_client_not_initialized_w_admin_flag(self): + def test_admin_transport_not_initialized_w_admin_flag(self): + from google.cloud.bigtable_admin_v2.gapic.transports import ( + bigtable_table_admin_grpc_transport, + ) + + channel = mock.Mock() + + client = self._make_one(project=self.PROJECT, admin=True) + + client.admin_transport = channel + self.assertTrue(callable(client.admin_transport)) + admin_transport = client.admin_transport( + default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport + ) + self.assertIsInstance( + admin_transport, + bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, + ) + + self.assertIsInstance( + client._admin_transport( + default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport + ), + bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, + ) + + def test_table_admin_client_not_initialized_w_admin_transport_w_channel(self): + from google.cloud.bigtable.client import _CLIENT_INFO + from google.cloud.bigtable_admin_v2 import BigtableTableAdminClient + from google.cloud.bigtable_admin_v2.gapic.transports import ( + bigtable_table_admin_grpc_transport, + ) + + client = self._make_one(project=self.PROJECT, admin=True) + + channel = mock.Mock() + + client.admin_transport = channel + + self.assertTrue(callable(client.admin_transport)) + admin_transport = client.admin_transport( + default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport + ) + + table_admin_client = client.table_admin_client + self.assertIsInstance( + admin_transport, + bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, + ) + + self.assertIsInstance( + table_admin_client.transport, + bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, + ) + + self.assertIsInstance(table_admin_client, BigtableTableAdminClient) + self.assertIs(table_admin_client._client_info, _CLIENT_INFO) + self.assertIs(client._table_admin_client, table_admin_client) + + def test_table_admin_client_not_initialized_w_admin_transport_w_credentials(self): from google.cloud.bigtable.client import _CLIENT_INFO from google.cloud.bigtable_admin_v2 import BigtableTableAdminClient @@ -235,7 +367,14 @@ def test_table_admin_client_not_initialized_w_admin_flag(self): project=self.PROJECT, credentials=credentials, admin=True ) + client.admin_transport = None + admin_transport = client.admin_transport + self.assertTrue(callable(admin_transport)) + + self.assertIsNot(client._credentials, None) + table_admin_client = client.table_admin_client + self.assertIsInstance(table_admin_client, BigtableTableAdminClient) self.assertIs(table_admin_client._client_info, _CLIENT_INFO) self.assertIs(client._table_admin_client, table_admin_client) @@ -287,6 +426,54 @@ def test_instance_admin_client_not_initialized_w_admin_flag(self): self.assertIs(instance_admin_client._client_info, _CLIENT_INFO) self.assertIs(client._instance_admin_client, instance_admin_client) + def test_instance_admin_client_not_initialized_w_admin_flag_w_channel(self): + from google.cloud.bigtable.client import _CLIENT_INFO + from google.cloud.bigtable_admin_v2 import BigtableInstanceAdminClient + from google.cloud.bigtable_admin_v2.gapic.transports import ( + bigtable_instance_admin_grpc_transport, + ) + + client = self._make_one(project=self.PROJECT, admin=True) + + channel = mock.Mock() + + client.admin_transport = channel + admin_transport = client.admin_transport( + default_class=bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport + ) + self.assertIsInstance( + admin_transport, + bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport, + ) + + instance_admin_client = client.instance_admin_client + self.assertIsInstance(instance_admin_client, BigtableInstanceAdminClient) + self.assertIs(instance_admin_client._client_info, _CLIENT_INFO) + self.assertIs(client._instance_admin_client, instance_admin_client) + + def test_instance_admin_client_not_initialized_w_admin_transport_w_credentials( + self + ): + from google.cloud.bigtable.client import _CLIENT_INFO + from google.cloud.bigtable_admin_v2 import BigtableInstanceAdminClient + + credentials = _make_credentials() + client = self._make_one( + project=self.PROJECT, credentials=credentials, admin=True + ) + + client.admin_transport = None + admin_transport = client.admin_transport + self.assertTrue(callable(admin_transport)) + + self.assertIsNot(client._credentials, None) + + instance_admin_client = client.instance_admin_client + + self.assertIsInstance(instance_admin_client, BigtableInstanceAdminClient) + self.assertIs(instance_admin_client._client_info, _CLIENT_INFO) + self.assertIs(client._instance_admin_client, instance_admin_client) + def test_instance_admin_client_not_initialized_w_admin_and_client_info(self): from google.cloud.bigtable_admin_v2 import BigtableInstanceAdminClient From 608f7553928d55372b202691eab651dfe1846a91 Mon Sep 17 00:00:00 2001 From: Sangram Date: Tue, 28 May 2019 03:33:31 +0530 Subject: [PATCH 2/2] Fix review comments --- bigtable/google/cloud/bigtable/client.py | 98 ++++++++++++--------- bigtable/tests/unit/test_client.py | 105 ++++++++--------------- 2 files changed, 92 insertions(+), 111 deletions(-) diff --git a/bigtable/google/cloud/bigtable/client.py b/bigtable/google/cloud/bigtable/client.py index 42cf37235d24..d1d9a5dbbcff 100644 --- a/bigtable/google/cloud/bigtable/client.py +++ b/bigtable/google/cloud/bigtable/client.py @@ -37,8 +37,8 @@ from google.cloud import bigtable_admin_v2 from google.cloud.bigtable_v2.gapic.transports import bigtable_grpc_transport from google.cloud.bigtable_admin_v2.gapic.transports import ( - bigtable_table_admin_grpc_transport, bigtable_instance_admin_grpc_transport, + bigtable_table_admin_grpc_transport, ) from google.cloud.bigtable import __version__ @@ -66,11 +66,26 @@ def _create_gapic_client(client_class): - def inner(self, transport=None): + def inner(self, transport_class=None): if self._emulator_host is None: - if transport is not None: - return client_class(transport=transport, client_info=self._client_info) + if transport_class is not None: + if self._channel is not None: + # Use transport with channel + transport_obj = _transport( + channel=self._channel, default_class=transport_class + ) + return client_class( + transport=transport_obj, client_info=self._client_info + ) + else: + # Use transport as pointer to function with credentials + return client_class( + transport=_transport, + credentials=self._credentials, + client_info=self._client_info, + ) else: + # Use credentials return client_class( credentials=self._credentials, client_info=self._client_info ) @@ -82,16 +97,27 @@ def inner(self, transport=None): return inner -def transport(channel=None): - def inner(credentials=None, default_class=None): +def _transport(channel=None, credentials=None, default_class=None): + """ Returns a object for gRPC class passed in argument default_class. + Args: + + channel (grpc.Channel): A ``Channel`` instance through + which to make calls. If not passed, it's None. + + credentials (google.auth.credentials.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If not passed, it's None. + + default_class (GrpcTransport): A transport + instance, responsible for actually making the API calls. + The default transport uses the gRPC protocol.. Defaults to None. + """ + if default_class is not None: if channel is not None: return default_class(channel=channel) elif credentials is not None: return default_class(credentials=credentials) - else: - return None - - return inner + return None class Client(ClientWithProject): @@ -237,14 +263,12 @@ def table_data_client(self): """ if self._table_data_client is None: if self._data_transport is not None: - transport = self.data_transport( - default_class=bigtable_grpc_transport.BigtableGrpcTransport - ) + transport_class = bigtable_grpc_transport.BigtableGrpcTransport else: - transport = None + transport_class = None self._table_data_client = _create_gapic_client(bigtable_v2.BigtableClient)( - self, transport=transport + self, transport_class=transport_class ) return self._table_data_client @@ -268,14 +292,15 @@ def table_admin_client(self): if not self._admin: raise ValueError("Client is not an admin client.") if self._admin_transport is not None: - transport = self.admin_transport( - default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport + transport_class = ( + bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport ) else: - transport = None + transport_class = None + self._table_admin_client = _create_gapic_client( bigtable_admin_v2.BigtableTableAdminClient - )(self, transport=transport) + )(self, transport_class=transport_class) return self._table_admin_client @property @@ -297,43 +322,34 @@ def instance_admin_client(self): if self._instance_admin_client is None: if not self._admin: raise ValueError("Client is not an admin client.") + if self._admin_transport is not None: - transport = self.admin_transport( - default_class=bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport + transport_class = ( + bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport ) else: - transport = None + transport_class = None self._instance_admin_client = _create_gapic_client( bigtable_admin_v2.BigtableInstanceAdminClient - )(self, transport=transport) + )(self, transport_class=transport_class) return self._instance_admin_client - @property - def data_transport(self): - return self._data_transport - - @data_transport.setter def data_transport(self, channel=None): if self._data_transport is None: - if channel is not None: - self._data_transport = transport(channel=channel) - elif self._credentials is not None: - self._data_transport = transport() + self._data_transport = _transport + self._channel = channel - @property - def admin_transport(self): - return self._admin_transport + return self._data_transport - @admin_transport.setter def admin_transport(self, channel=None): - if self._admin_transport is None: if not self._admin: raise ValueError("Client is not an admin client.") - if channel is not None: - self._admin_transport = transport(channel=channel) - elif self._credentials is not None: - self._admin_transport = transport() + + self._admin_transport = _transport + self._channel = channel + + return self._admin_transport def instance(self, instance_id, display_name=None, instance_type=None, labels=None): """Factory to create a instance associated with this client. diff --git a/bigtable/tests/unit/test_client.py b/bigtable/tests/unit/test_client.py index d6f83cf41f3b..c7c530d4c283 100644 --- a/bigtable/tests/unit/test_client.py +++ b/bigtable/tests/unit/test_client.py @@ -211,27 +211,13 @@ def test_table_data_client_not_initialized_w_client_info(self): self.assertIs(client._table_data_client, table_data_client) def test_data_transport_not_initialized_w_admin_flag(self): - from google.cloud.bigtable_v2.gapic.transports import bigtable_grpc_transport - - channel = mock.Mock() - client = self._make_one(project=self.PROJECT, admin=True) - client.data_transport = channel self.assertTrue(callable(client.data_transport)) - data_transport = client.data_transport( - default_class=bigtable_grpc_transport.BigtableGrpcTransport - ) - self.assertIsInstance( - data_transport, bigtable_grpc_transport.BigtableGrpcTransport - ) + data_transport = client.data_transport() + self.assertTrue(callable(data_transport)) - self.assertIsInstance( - client._data_transport( - default_class=bigtable_grpc_transport.BigtableGrpcTransport - ), - bigtable_grpc_transport.BigtableGrpcTransport, - ) + self.assertIsNone(data_transport()) def test_table_data_client_not_initialized_w_data_transport_w_channel(self): from google.cloud.bigtable.client import _CLIENT_INFO @@ -242,22 +228,19 @@ def test_table_data_client_not_initialized_w_data_transport_w_channel(self): channel = mock.Mock() - client.data_transport = channel + data_transport = client.data_transport(channel=channel) - self.assertTrue(callable(client.data_transport)) - data_transport = client.data_transport( - default_class=bigtable_grpc_transport.BigtableGrpcTransport - ) + self.assertTrue(callable(data_transport)) - table_data_client = client.table_data_client - self.assertIsInstance( - data_transport, bigtable_grpc_transport.BigtableGrpcTransport + data_transport_obj = data_transport( + channel=channel, default_class=bigtable_grpc_transport.BigtableGrpcTransport ) self.assertIsInstance( - table_data_client.transport, bigtable_grpc_transport.BigtableGrpcTransport + data_transport_obj, bigtable_grpc_transport.BigtableGrpcTransport ) + table_data_client = client.table_data_client self.assertIsInstance(table_data_client, BigtableClient) self.assertIs(table_data_client._client_info, _CLIENT_INFO) self.assertIs(client._table_data_client, table_data_client) @@ -271,11 +254,10 @@ def test_table_data_client_not_initialized_w_data_transport_w_credentials(self): project=self.PROJECT, credentials=credentials, admin=True ) - client.data_transport = None - data_transport = client.data_transport + data_transport = client.data_transport() self.assertTrue(callable(data_transport)) - self.assertIsNot(client._credentials, None) + self.assertIsNotNone(client._credentials) table_data_client = client.table_data_client @@ -300,30 +282,13 @@ def test_table_admin_client_not_initialized_no_admin_flag(self): client.table_admin_client() def test_admin_transport_not_initialized_w_admin_flag(self): - from google.cloud.bigtable_admin_v2.gapic.transports import ( - bigtable_table_admin_grpc_transport, - ) - - channel = mock.Mock() - client = self._make_one(project=self.PROJECT, admin=True) - client.admin_transport = channel self.assertTrue(callable(client.admin_transport)) - admin_transport = client.admin_transport( - default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport - ) - self.assertIsInstance( - admin_transport, - bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, - ) + admin_transport = client.admin_transport() + self.assertTrue(callable(admin_transport)) - self.assertIsInstance( - client._admin_transport( - default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport - ), - bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, - ) + self.assertIsNone(admin_transport()) def test_table_admin_client_not_initialized_w_admin_transport_w_channel(self): from google.cloud.bigtable.client import _CLIENT_INFO @@ -336,24 +301,21 @@ def test_table_admin_client_not_initialized_w_admin_transport_w_channel(self): channel = mock.Mock() - client.admin_transport = channel + admin_transport = client.admin_transport(channel=channel) - self.assertTrue(callable(client.admin_transport)) - admin_transport = client.admin_transport( - default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport - ) + self.assertTrue(callable(admin_transport)) - table_admin_client = client.table_admin_client - self.assertIsInstance( - admin_transport, - bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, + admin_transport_obj = admin_transport( + channel=channel, + default_class=bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, ) self.assertIsInstance( - table_admin_client.transport, + admin_transport_obj, bigtable_table_admin_grpc_transport.BigtableTableAdminGrpcTransport, ) + table_admin_client = client.table_admin_client self.assertIsInstance(table_admin_client, BigtableTableAdminClient) self.assertIs(table_admin_client._client_info, _CLIENT_INFO) self.assertIs(client._table_admin_client, table_admin_client) @@ -367,11 +329,10 @@ def test_table_admin_client_not_initialized_w_admin_transport_w_credentials(self project=self.PROJECT, credentials=credentials, admin=True ) - client.admin_transport = None - admin_transport = client.admin_transport + admin_transport = client.admin_transport() self.assertTrue(callable(admin_transport)) - self.assertIsNot(client._credentials, None) + self.assertIsNotNone(client._credentials) table_admin_client = client.table_admin_client @@ -426,7 +387,7 @@ def test_instance_admin_client_not_initialized_w_admin_flag(self): self.assertIs(instance_admin_client._client_info, _CLIENT_INFO) self.assertIs(client._instance_admin_client, instance_admin_client) - def test_instance_admin_client_not_initialized_w_admin_flag_w_channel(self): + def test_instance_admin_client_not_initialized_w_admin_transport_w_channel(self): from google.cloud.bigtable.client import _CLIENT_INFO from google.cloud.bigtable_admin_v2 import BigtableInstanceAdminClient from google.cloud.bigtable_admin_v2.gapic.transports import ( @@ -437,12 +398,17 @@ def test_instance_admin_client_not_initialized_w_admin_flag_w_channel(self): channel = mock.Mock() - client.admin_transport = channel - admin_transport = client.admin_transport( - default_class=bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport + admin_transport = client.admin_transport(channel=channel) + + self.assertTrue(callable(admin_transport)) + + admin_transport_obj = admin_transport( + channel=channel, + default_class=bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport, ) + self.assertIsInstance( - admin_transport, + admin_transport_obj, bigtable_instance_admin_grpc_transport.BigtableInstanceAdminGrpcTransport, ) @@ -462,11 +428,10 @@ def test_instance_admin_client_not_initialized_w_admin_transport_w_credentials( project=self.PROJECT, credentials=credentials, admin=True ) - client.admin_transport = None - admin_transport = client.admin_transport + admin_transport = client.admin_transport() self.assertTrue(callable(admin_transport)) - self.assertIsNot(client._credentials, None) + self.assertIsNotNone(client._credentials) instance_admin_client = client.instance_admin_client