test(gapic): consolidate async otel tests into test_method_async and share fixtures

Author: chalmerlowe

packages/google-api-core/tests/asyncio/gapic/test_method_async.py

@@ -26,13 +26,18 @@
 except ImportError:
     pytest.skip("No GRPC", allow_module_level=True)
 
+from google.api_core import (
+    client_options as client_options_lib,
+)
 from google.api_core import (
     exceptions,
     gapic_v1,
     grpc_helpers_async,
     retry_async,
     timeout,
 )
+from google.api_core.gapic_v1 import client_info
+from tests.helpers import assert_uninstrumented_gapic_callable
 
 
 def _utcnow_monotonic():
@@ -276,50 +281,104 @@ async def test_wrap_method_without_wrap_errors():
         method.assert_not_called()
 
 
+_ASYNC_SERVICE_DEFAULT_SPAN_ATTRIBUTES = {
+    "rpc.system": "grpc",
+    "rpc.service": "google.test.AsyncService",
+    "rpc.method": "AsyncMethod",
+    "gcp.client.service": "AsyncService",
+    "gcp.client.repo": "googleapis/google-cloud-python",
+}
+
+
 @pytest.mark.asyncio
-async def test_wrap_method_async_with_otel_tracing(monkeypatch):
-    import sys
+async def test_wrap_method_async_with_otel_tracing(mock_otel):
+    """Proves that method_async.wrap_method creates a T3 span upon invocation."""
+    fake_call = grpc_helpers_async.FakeUnaryUnaryCall(42)
+    method = mock.Mock(spec=aio.UnaryUnaryMultiCallable, return_value=fake_call)
+
+    wrapped_method = gapic_v1.method_async.wrap_method(
+        method,
+        method_name="google.test.AsyncService/AsyncMethod",
+    )
+    result = await wrapped_method(1, 2, meep="moop")
 
-    monkeypatch.setenv("GOOGLE_SDK_EXPERIMENTAL_PYTHON_TRACING_ENABLED", "true")
+    assert result == 42
+    mock_otel.tracer.start_as_current_span.assert_called_once_with(
+        "google.test.AsyncService/AsyncMethod",
+        kind="CLIENT",
+        attributes=_ASYNC_SERVICE_DEFAULT_SPAN_ATTRIBUTES,
+    )
+
+
+@pytest.mark.asyncio
+async def test_wrap_method_async_otel_tracing_streaming_skips_span(mock_otel):
+    """Proves that method_async.wrap_method with is_streaming=True skips span creation."""
     fake_call = grpc_helpers_async.FakeUnaryUnaryCall(42)
     method = mock.Mock(spec=aio.UnaryUnaryMultiCallable, return_value=fake_call)
 
-    mock_span = mock.MagicMock()
-    mock_tracer = mock.MagicMock()
-    mock_tracer.start_as_current_span.return_value.__enter__.return_value = mock_span
+    wrapped = gapic_v1.method_async.wrap_method(
+        method,
+        method_name="google.test.AsyncService/AsyncMethod",
+        is_streaming=True,
+    )
+    result = await wrapped(1, 2)
+
+    assert_uninstrumented_gapic_callable(
+        wrapped,
+        result,
+        method,
+        mock_trace=mock_otel.trace,
+        expected_result=42,
+    )
 
-    mock_trace = mock.Mock()
-    mock_trace.get_tracer.return_value = mock_tracer
-    mock_trace.SpanKind.CLIENT = "CLIENT"
 
-    with (
-        mock.patch(
-            "google.api_core._observability.is_otel_capabilities_enabled",
-            return_value=True,
-        ),
-        mock.patch.dict(
-            sys.modules,
-            {
-                "opentelemetry": mock.Mock(trace=mock_trace),
-                "opentelemetry.trace": mock_trace,
-            },
-        ),
-    ):
-        wrapped_method = gapic_v1.method_async.wrap_method(
-            method,
-            method_name="google.test.AsyncService/AsyncMethod",
-        )
-        result = await wrapped_method(1, 2, meep="moop")
+@pytest.mark.asyncio
+async def test_wrap_method_async_otel_tracing_custom_client_options(mock_otel):
+    """Proves that method_async.wrap_method forwards custom client_options tracer_provider."""
+    fake_call = grpc_helpers_async.FakeUnaryUnaryCall(42)
+    method = mock.Mock(spec=aio.UnaryUnaryMultiCallable, return_value=fake_call)
+
+    mock_provider = mock.Mock()
+    mock_provider.get_tracer.return_value = mock_otel.tracer
+    client_options = client_options_lib.ClientOptions(tracer_provider=mock_provider)
+
+    wrapped = gapic_v1.method_async.wrap_method(
+        method,
+        client_options=client_options,
+        method_name="google.test.AsyncService/AsyncMethod",
+    )
+    result = await wrapped(1, 2)
+
+    assert result == 42
+    mock_provider.get_tracer.assert_called_once_with("google.api_core")
+    mock_otel.tracer.start_as_current_span.assert_called_once_with(
+        "google.test.AsyncService/AsyncMethod",
+        kind="CLIENT",
+        attributes=_ASYNC_SERVICE_DEFAULT_SPAN_ATTRIBUTES,
+    )
+
+
+@pytest.mark.asyncio
+async def test_wrap_method_async_otel_tracing_with_client_info(mock_otel):
+    """Proves that method_async.wrap_method passes client_info to _GapicCallable."""
+    fake_call = grpc_helpers_async.FakeUnaryUnaryCall(42)
+    method = mock.Mock(spec=aio.UnaryUnaryMultiCallable, return_value=fake_call)
+
+    info = client_info.ClientInfo(client_library_version="3.0.0")
+
+    wrapped = gapic_v1.method_async.wrap_method(
+        method,
+        client_info=info,
+        method_name="google.test.AsyncService/AsyncMethod",
+    )
+    result = await wrapped(1, 2)
 
     assert result == 42
-    mock_tracer.start_as_current_span.assert_called_once_with(
+    mock_otel.tracer.start_as_current_span.assert_called_once_with(
         "google.test.AsyncService/AsyncMethod",
         kind="CLIENT",
         attributes={
-            "rpc.system": "grpc",
-            "rpc.service": "google.test.AsyncService",
-            "rpc.method": "AsyncMethod",
-            "gcp.client.service": "AsyncService",
-            "gcp.client.repo": "googleapis/google-cloud-python",
+            **_ASYNC_SERVICE_DEFAULT_SPAN_ATTRIBUTES,
+            "gcp.client.version": "3.0.0",
         },
     )

packages/google-api-core/tests/conftest.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 
 import os
+import sys
+import types
 from unittest import mock
 
 import pytest
@@ -29,3 +31,36 @@ def mock_mtls_env():
         },
     ):
         yield
+
+
+@pytest.fixture
+def mock_otel(monkeypatch):
+    """Provides a mocked OpenTelemetry environment with tracing enabled."""
+    monkeypatch.setenv("GOOGLE_SDK_EXPERIMENTAL_PYTHON_TRACING_ENABLED", "true")
+    mock_span = mock.MagicMock()
+    mock_tracer = mock.MagicMock()
+    mock_tracer.start_as_current_span.return_value.__enter__.return_value = mock_span
+
+    mock_trace = mock.Mock()
+    mock_trace.get_tracer.return_value = mock_tracer
+    mock_trace.SpanKind.CLIENT = "CLIENT"
+    mock_trace.StatusCode.ERROR = "ERROR"
+
+    with (
+        mock.patch(
+            "google.api_core._observability.is_otel_capabilities_enabled",
+            return_value=True,
+        ),
+        mock.patch.dict(
+            sys.modules,
+            {
+                "opentelemetry": mock.Mock(trace=mock_trace),
+                "opentelemetry.trace": mock_trace,
+            },
+        ),
+    ):
+        yield types.SimpleNamespace(
+            trace=mock_trace,
+            tracer=mock_tracer,
+            span=mock_span,
+        )

packages/google-api-core/tests/helpers.py

@@ -78,3 +78,30 @@ def parse_responses(response_message_cls, all_responses: List[proto.Message]) ->
     DeprecationWarning,
     match="argument is deprecated because of a potential security risk",
 )
+
+
+def assert_uninstrumented_gapic_callable(
+    wrapped,
+    result,
+    mock_target,
+    mock_trace=None,
+    expected_result="success",
+):
+    """Verifies that an uninstrumented RPC callable succeeds without tracing overhead.
+
+    1. Proves the RPC executed successfully with the expected return value.
+    2. Proves the OpenTelemetry API was never invoked.
+    3. Proves the callable holds no tracer or span configuration.
+    """
+    # 1. Prove the RPC executed successfully
+    assert result == expected_result
+    mock_target.assert_called_once()
+
+    # 2. Prove the OpenTelemetry API was never invoked
+    if mock_trace is not None:
+        mock_trace.get_tracer.assert_not_called()
+
+    # 3. Prove the callable holds no tracer or span configuration
+    assert wrapped._tracer is None
+    assert wrapped._span_name is None
+    assert wrapped._span_attributes is None