diff --git a/google/cloud/debugger_v2/services/controller2/async_client.py b/google/cloud/debugger_v2/services/controller2/async_client.py index 6799237..8f6c5a4 100644 --- a/google/cloud/debugger_v2/services/controller2/async_client.py +++ b/google/cloud/debugger_v2/services/controller2/async_client.py @@ -244,16 +244,16 @@ async def register_debuggee( from google.cloud import debugger_v2 - def sample_register_debuggee(): + async def sample_register_debuggee(): # Create a client - client = debugger_v2.Controller2Client() + client = debugger_v2.Controller2AsyncClient() # Initialize request argument(s) request = debugger_v2.RegisterDebuggeeRequest( ) # Make the request - response = client.register_debuggee(request=request) + response = await client.register_debuggee(request=request) # Handle the response print(response) @@ -343,9 +343,9 @@ async def list_active_breakpoints( from google.cloud import debugger_v2 - def sample_list_active_breakpoints(): + async def sample_list_active_breakpoints(): # Create a client - client = debugger_v2.Controller2Client() + client = debugger_v2.Controller2AsyncClient() # Initialize request argument(s) request = debugger_v2.ListActiveBreakpointsRequest( @@ -353,7 +353,7 @@ def sample_list_active_breakpoints(): ) # Make the request - response = client.list_active_breakpoints(request=request) + response = await client.list_active_breakpoints(request=request) # Handle the response print(response) @@ -413,6 +413,14 @@ def sample_list_active_breakpoints(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = await rpc( request, @@ -448,9 +456,9 @@ async def update_active_breakpoint( from google.cloud import debugger_v2 - def sample_update_active_breakpoint(): + async def sample_update_active_breakpoint(): # Create a client - client = debugger_v2.Controller2Client() + client = debugger_v2.Controller2AsyncClient() # Initialize request argument(s) request = debugger_v2.UpdateActiveBreakpointRequest( @@ -458,7 +466,7 @@ def sample_update_active_breakpoint(): ) # Make the request - response = client.update_active_breakpoint(request=request) + response = await client.update_active_breakpoint(request=request) # Handle the response print(response) @@ -532,6 +540,17 @@ def sample_update_active_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint.id", request.breakpoint_.id), + ) + ), + ) + # Send the request. response = await rpc( request, diff --git a/google/cloud/debugger_v2/services/controller2/client.py b/google/cloud/debugger_v2/services/controller2/client.py index 88d5595..06787c5 100644 --- a/google/cloud/debugger_v2/services/controller2/client.py +++ b/google/cloud/debugger_v2/services/controller2/client.py @@ -609,6 +609,14 @@ def sample_list_active_breakpoints(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.list_active_breakpoints] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = rpc( request, @@ -718,6 +726,17 @@ def sample_update_active_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.update_active_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint.id", request.breakpoint_.id), + ) + ), + ) + # Send the request. response = rpc( request, diff --git a/google/cloud/debugger_v2/services/debugger2/async_client.py b/google/cloud/debugger_v2/services/debugger2/async_client.py index 77822c6..a1fb80f 100644 --- a/google/cloud/debugger_v2/services/debugger2/async_client.py +++ b/google/cloud/debugger_v2/services/debugger2/async_client.py @@ -224,9 +224,9 @@ async def set_breakpoint( from google.cloud import debugger_v2 - def sample_set_breakpoint(): + async def sample_set_breakpoint(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.SetBreakpointRequest( @@ -235,7 +235,7 @@ def sample_set_breakpoint(): ) # Make the request - response = client.set_breakpoint(request=request) + response = await client.set_breakpoint(request=request) # Handle the response print(response) @@ -304,6 +304,14 @@ def sample_set_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = await rpc( request, @@ -332,9 +340,9 @@ async def get_breakpoint( from google.cloud import debugger_v2 - def sample_get_breakpoint(): + async def sample_get_breakpoint(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.GetBreakpointRequest( @@ -344,7 +352,7 @@ def sample_get_breakpoint(): ) # Make the request - response = client.get_breakpoint(request=request) + response = await client.get_breakpoint(request=request) # Handle the response print(response) @@ -426,6 +434,17 @@ def sample_get_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. response = await rpc( request, @@ -454,9 +473,9 @@ async def delete_breakpoint( from google.cloud import debugger_v2 - def sample_delete_breakpoint(): + async def sample_delete_breakpoint(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.DeleteBreakpointRequest( @@ -466,7 +485,7 @@ def sample_delete_breakpoint(): ) # Make the request - client.delete_breakpoint(request=request) + await client.delete_breakpoint(request=request) Args: request (Union[google.cloud.debugger_v2.types.DeleteBreakpointRequest, dict]): @@ -538,6 +557,17 @@ def sample_delete_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. await rpc( request, @@ -562,9 +592,9 @@ async def list_breakpoints( from google.cloud import debugger_v2 - def sample_list_breakpoints(): + async def sample_list_breakpoints(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.ListBreakpointsRequest( @@ -573,7 +603,7 @@ def sample_list_breakpoints(): ) # Make the request - response = client.list_breakpoints(request=request) + response = await client.list_breakpoints(request=request) # Handle the response print(response) @@ -643,6 +673,14 @@ def sample_list_breakpoints(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = await rpc( request, @@ -670,9 +708,9 @@ async def list_debuggees( from google.cloud import debugger_v2 - def sample_list_debuggees(): + async def sample_list_debuggees(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.ListDebuggeesRequest( @@ -681,7 +719,7 @@ def sample_list_debuggees(): ) # Make the request - response = client.list_debuggees(request=request) + response = await client.list_debuggees(request=request) # Handle the response print(response) diff --git a/google/cloud/debugger_v2/services/debugger2/client.py b/google/cloud/debugger_v2/services/debugger2/client.py index cba0b05..c847870 100644 --- a/google/cloud/debugger_v2/services/debugger2/client.py +++ b/google/cloud/debugger_v2/services/debugger2/client.py @@ -512,6 +512,14 @@ def sample_set_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.set_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = rpc( request, @@ -624,6 +632,17 @@ def sample_get_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.get_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. response = rpc( request, @@ -726,6 +745,17 @@ def sample_delete_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.delete_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. rpc( request, @@ -821,6 +851,14 @@ def sample_list_breakpoints(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.list_breakpoints] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = rpc( request, diff --git a/owlbot.py b/owlbot.py index 22cc59f..ac60721 100644 --- a/owlbot.py +++ b/owlbot.py @@ -51,6 +51,15 @@ "google.cloud.source_context_v1.types.source_context_pb2" ) + s.replace( + [ + library / f"google/cloud/debugger_{library.name}/services/**/*client.py", + library / f"tests/unit/gapic/debugger_{library.name}/test_controller2.py", + ], + "request\.breakpoint\.", + "request.breakpoint_." + ) + s.move(library, excludes=["setup.py", "README.rst", "docs/index.rst"]) s.remove_staging_dirs() diff --git a/tests/unit/gapic/debugger_v2/test_controller2.py b/tests/unit/gapic/debugger_v2/test_controller2.py index 6ead507..c80ac38 100644 --- a/tests/unit/gapic/debugger_v2/test_controller2.py +++ b/tests/unit/gapic/debugger_v2/test_controller2.py @@ -903,6 +903,71 @@ async def test_list_active_breakpoints_async_from_dict(): await test_list_active_breakpoints_async(request_type=dict) +def test_list_active_breakpoints_field_headers(): + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.ListActiveBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_active_breakpoints), "__call__" + ) as call: + call.return_value = controller.ListActiveBreakpointsResponse() + client.list_active_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_active_breakpoints_field_headers_async(): + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.ListActiveBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_active_breakpoints), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + controller.ListActiveBreakpointsResponse() + ) + await client.list_active_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + def test_list_active_breakpoints_flattened(): client = Controller2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -1079,6 +1144,73 @@ async def test_update_active_breakpoint_async_from_dict(): await test_update_active_breakpoint_async(request_type=dict) +def test_update_active_breakpoint_field_headers(): + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.UpdateActiveBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_.id = "id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_active_breakpoint), "__call__" + ) as call: + call.return_value = controller.UpdateActiveBreakpointResponse() + client.update_active_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint.id=id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_update_active_breakpoint_field_headers_async(): + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.UpdateActiveBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_.id = "id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_active_breakpoint), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + controller.UpdateActiveBreakpointResponse() + ) + await client.update_active_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint.id=id_value", + ) in kw["metadata"] + + def test_update_active_breakpoint_flattened(): client = Controller2Client( credentials=ga_credentials.AnonymousCredentials(), diff --git a/tests/unit/gapic/debugger_v2/test_debugger2.py b/tests/unit/gapic/debugger_v2/test_debugger2.py index fab5ff2..4d17875 100644 --- a/tests/unit/gapic/debugger_v2/test_debugger2.py +++ b/tests/unit/gapic/debugger_v2/test_debugger2.py @@ -706,6 +706,67 @@ async def test_set_breakpoint_async_from_dict(): await test_set_breakpoint_async(request_type=dict) +def test_set_breakpoint_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.SetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_breakpoint), "__call__") as call: + call.return_value = debugger.SetBreakpointResponse() + client.set_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_set_breakpoint_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.SetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_breakpoint), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + debugger.SetBreakpointResponse() + ) + await client.set_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + def test_set_breakpoint_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -891,6 +952,69 @@ async def test_get_breakpoint_async_from_dict(): await test_get_breakpoint_async(request_type=dict) +def test_get_breakpoint_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.GetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_breakpoint), "__call__") as call: + call.return_value = debugger.GetBreakpointResponse() + client.get_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_breakpoint_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.GetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_breakpoint), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + debugger.GetBreakpointResponse() + ) + await client.get_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + def test_get_breakpoint_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -1080,6 +1204,71 @@ async def test_delete_breakpoint_async_from_dict(): await test_delete_breakpoint_async(request_type=dict) +def test_delete_breakpoint_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.DeleteBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_breakpoint), "__call__" + ) as call: + call.return_value = None + client.delete_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_breakpoint_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.DeleteBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_breakpoint), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + def test_delete_breakpoint_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -1273,6 +1462,67 @@ async def test_list_breakpoints_async_from_dict(): await test_list_breakpoints_async(request_type=dict) +def test_list_breakpoints_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.ListBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: + call.return_value = debugger.ListBreakpointsResponse() + client.list_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_breakpoints_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.ListBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + debugger.ListBreakpointsResponse() + ) + await client.list_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + def test_list_breakpoints_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(),