fixed tests

Author: daniel-sanche

packages/google-cloud-bigtable/tests/unit/data/_async/test_client.py

@@ -223,26 +223,32 @@ async def test_ctor_dict_options(self):
             await client.close()
 
     @CrossSync.pytest
-    async def test_metrics_exporter_init_shares_arguments(self):
+    @mock.patch("google.cloud.bigtable.data._async.client.BigtableMetricsExporter")
+    @mock.patch(
+        "google.cloud.bigtable.data._sync_autogen.client.BigtableMetricsExporter"
+    )
+    async def test_metrics_exporter_init_shares_arguments(
+        self, exporter_mock_sync, exporter_mock_async
+    ):
         expected_credentials = AnonymousCredentials()
         expected_project = "custom_project"
         expected_options = client_options.ClientOptions()
         expected_options.credentials_file = None
         expected_options.quota_project_id = None
-        with mock.patch(
-            "google.cloud.bigtable.data._metrics.handlers.gcp_exporter.BigtableMetricsExporter",
-        ) as exporter_mock:
-            async with self._make_client(
-                project=expected_project,
+        mock_called = (
+            exporter_mock_async if CrossSync.is_async else exporter_mock_sync
+        )
+        async with self._make_client(
+            project=expected_project,
+            credentials=expected_credentials,
+            client_options=expected_options,
+            use_emulator=False,
+        ):
+            mock_called.assert_called_once_with(
+                project_id=expected_project,
                 credentials=expected_credentials,
                 client_options=expected_options,
-                use_emulator=False,
-            ):
-                exporter_mock.assert_called_once_with(
-                    project_id=expected_project,
-                    credentials=expected_credentials,
-                    client_options=expected_options,
-                )
+            )
 
     @CrossSync.pytest
     async def test_metrics_exporter_init_implicit_project(self):
@@ -1268,13 +1274,20 @@ def _make_one(
             client, instance_id, table_id, app_profile_id, **kwargs
         )
 
+    @pytest.mark.parametrize("use_emulator", [True, False])
     @CrossSync.pytest
-    async def test_ctor(self):
+    async def test_ctor(self, use_emulator):
         from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
         from google.cloud.bigtable.data._metrics import (
             BigtableClientSideMetricsController,
             GoogleCloudMetricsHandler,
         )
+        from google.cloud.bigtable.data._metrics.handlers.gcp_exporter import (
+            BigtableMetricsExporter,
+        )
+        from google.cloud.bigtable.data._metrics.handlers.opentelemetry import (
+            OpenTelemetryMetricsHandler,
+        )
 
         expected_table_id = "table-id"
         expected_instance_id = "instance-id"
@@ -1285,7 +1298,7 @@ async def test_ctor(self):
         expected_read_rows_attempt_timeout = 0.5
         expected_mutate_rows_operation_timeout = 2.5
         expected_mutate_rows_attempt_timeout = 0.75
-        client = self._make_client(use_emulator=False)
+        client = self._make_client(use_emulator=use_emulator)
         assert not client._active_instances
 
         table = self._get_target_class()(
@@ -1318,7 +1331,12 @@ async def test_ctor(self):
         assert client._instance_owners[instance_key] == {id(table)}
         assert isinstance(client._metrics, BigtableClientSideMetricsController)
         assert len(client._metrics.handlers) == 1
-        assert isinstance(client._metrics.handlers[0], GoogleCloudMetricsHandler)
+        if use_emulator:
+            assert isinstance(client._metrics.handlers[0], OpenTelemetryMetricsHandler)
+            assert client._gcp_metrics_exporter is None
+        else:
+            assert isinstance(client._metrics.handlers[0], GoogleCloudMetricsHandler)
+            assert isinstance(client._gcp_metrics_exporter, BigtableMetricsExporter)
         assert table.default_operation_timeout == expected_operation_timeout
         assert table.default_attempt_timeout == expected_attempt_timeout
         assert (
@@ -1337,11 +1355,13 @@ async def test_ctor(self):
             table.default_mutate_rows_attempt_timeout
             == expected_mutate_rows_attempt_timeout
         )
-        # ensure task reaches completion
-        await table._register_instance_future
-        assert table._register_instance_future.done()
-        assert not table._register_instance_future.cancelled()
-        assert table._register_instance_future.exception() is None
+        if use_emulator:
+            await table._register_instance_future
+            assert table._register_instance_future.done()
+            assert not table._register_instance_future.cancelled()
+            assert table._register_instance_future.exception() is None
+        elif table._register_instance_future:
+            table._register_instance_future.cancel()
         await client.close()
 
     @CrossSync.pytest
@@ -1630,13 +1650,20 @@ def _make_one(
             client, instance_id, table_id, view_id, app_profile_id, **kwargs
         )
 
+    @pytest.mark.parametrize("use_emulator", [True, False])
     @CrossSync.pytest
-    async def test_ctor(self):
+    async def test_ctor(self, use_emulator):
         from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
         from google.cloud.bigtable.data._metrics import (
             BigtableClientSideMetricsController,
             GoogleCloudMetricsHandler,
         )
+        from google.cloud.bigtable.data._metrics.handlers.gcp_exporter import (
+            BigtableMetricsExporter,
+        )
+        from google.cloud.bigtable.data._metrics.handlers.opentelemetry import (
+            OpenTelemetryMetricsHandler,
+        )
 
         expected_table_id = "table-id"
         expected_instance_id = "instance-id"
@@ -1648,7 +1675,7 @@ async def test_ctor(self):
         expected_read_rows_attempt_timeout = 0.5
         expected_mutate_rows_operation_timeout = 2.5
         expected_mutate_rows_attempt_timeout = 0.75
-        client = self._make_client(use_emulator=False)
+        client = self._make_client(use_emulator=use_emulator)
         assert not client._active_instances
 
         view = self._get_target_class()(
@@ -1687,7 +1714,12 @@ async def test_ctor(self):
         assert client._instance_owners[instance_key] == {id(view)}
         assert isinstance(client._metrics, BigtableClientSideMetricsController)
         assert len(client._metrics.handlers) == 1
-        assert isinstance(client._metrics.handlers[0], GoogleCloudMetricsHandler)
+        if use_emulator:
+            assert isinstance(client._metrics.handlers[0], OpenTelemetryMetricsHandler)
+            assert client._gcp_metrics_exporter is None
+        else:
+            assert isinstance(client._metrics.handlers[0], GoogleCloudMetricsHandler)
+            assert isinstance(client._gcp_metrics_exporter, BigtableMetricsExporter)
         assert view.default_operation_timeout == expected_operation_timeout
         assert view.default_attempt_timeout == expected_attempt_timeout
         assert (
@@ -1705,11 +1737,13 @@ async def test_ctor(self):
             view.default_mutate_rows_attempt_timeout
             == expected_mutate_rows_attempt_timeout
         )
-        # ensure task reaches completion
-        await view._register_instance_future
-        assert view._register_instance_future.done()
-        assert not view._register_instance_future.cancelled()
-        assert view._register_instance_future.exception() is None
+        if use_emulator:
+            await view._register_instance_future
+            assert view._register_instance_future.done()
+            assert not view._register_instance_future.cancelled()
+            assert view._register_instance_future.exception() is None
+        elif view._register_instance_future:
+            view._register_instance_future.cancel()
         await client.close()
 
 
@@ -1738,11 +1772,19 @@ def _make_one(
             client, instance_id, view_id, app_profile_id, **kwargs
         )
 
+    @pytest.mark.parametrize("use_emulator", [True, False])
     @CrossSync.pytest
-    async def test_ctor(self):
+    async def test_ctor(self, use_emulator):
         from google.cloud.bigtable.data._helpers import _WarmedInstanceKey
         from google.cloud.bigtable.data._metrics import (
             BigtableClientSideMetricsController,
+            GoogleCloudMetricsHandler,
+        )
+        from google.cloud.bigtable.data._metrics.handlers.gcp_exporter import (
+            BigtableMetricsExporter,
+        )
+        from google.cloud.bigtable.data._metrics.handlers.opentelemetry import (
+            OpenTelemetryMetricsHandler,
         )
 
         expected_instance_id = "instance-id"
@@ -1754,7 +1796,7 @@ async def test_ctor(self):
         expected_read_rows_attempt_timeout = 0.5
         expected_mutate_rows_operation_timeout = 2.5
         expected_mutate_rows_attempt_timeout = 0.75
-        client = self._make_client()
+        client = self._make_client(use_emulator=use_emulator)
         assert not client._active_instances
 
         view = self._get_target_class()(
@@ -1786,6 +1828,13 @@ async def test_ctor(self):
         assert instance_key in client._active_instances
         assert client._instance_owners[instance_key] == {id(view)}
         assert isinstance(client._metrics, BigtableClientSideMetricsController)
+        assert len(client._metrics.handlers) == 1
+        if use_emulator:
+            assert isinstance(client._metrics.handlers[0], OpenTelemetryMetricsHandler)
+            assert client._gcp_metrics_exporter is None
+        else:
+            assert isinstance(client._metrics.handlers[0], GoogleCloudMetricsHandler)
+            assert isinstance(client._gcp_metrics_exporter, BigtableMetricsExporter)
         assert view.default_operation_timeout == expected_operation_timeout
         assert view.default_attempt_timeout == expected_attempt_timeout
         assert (
@@ -1803,11 +1852,13 @@ async def test_ctor(self):
             view.default_mutate_rows_attempt_timeout
             == expected_mutate_rows_attempt_timeout
         )
-        # ensure task reaches completion
-        await view._register_instance_future
-        assert view._register_instance_future.done()
-        assert not view._register_instance_future.cancelled()
-        assert view._register_instance_future.exception() is None
+        if use_emulator:
+            await view._register_instance_future
+            assert view._register_instance_future.done()
+            assert not view._register_instance_future.cancelled()
+            assert view._register_instance_future.exception() is None
+        elif view._register_instance_future:
+            view._register_instance_future.cancel()
         await client.close()
 
     @pytest.mark.parametrize(