diff --git a/packages/gapic-generator/gapic/ads-templates/%namespace/%name/%version/%sub/services/%service/transports/rest_base.py.j2 b/packages/gapic-generator/gapic/ads-templates/%namespace/%name/%version/%sub/services/%service/transports/rest_base.py.j2 index 29b64f00087c..87c9c66d813c 100644 --- a/packages/gapic-generator/gapic/ads-templates/%namespace/%name/%version/%sub/services/%service/transports/rest_base.py.j2 +++ b/packages/gapic-generator/gapic/ads-templates/%namespace/%name/%version/%sub/services/%service/transports/rest_base.py.j2 @@ -124,14 +124,10 @@ class _Base{{ service.name }}RestTransport({{service.name}}Transport): "{{ req_field.name | camel_case }}" : {% if req_field.field_pb.type == 9 %}"{{req_field.field_pb.default_value }}"{% elif req_field.field_pb.type in [11, 14] %}{}{% else %}{{ req_field.type.python_type(req_field.field_pb.default_value or 0) }}{% endif %},{# default is str #} {% endfor %} } - - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} {% endif %}{# required fields #} - + {% set method_http_options = method.http_options %} - + {{ shared_macros.http_options_method(method_http_options)|indent(8) }} @staticmethod @@ -166,7 +162,8 @@ class _Base{{ service.name }}RestTransport({{service.name}}Transport): use_integers_for_enums={{ opts.rest_numeric_enums }}, )) {% if method.input.required_fields %} - query_params.update(_Base{{ service.name }}RestTransport._Base{{method.name}}._get_unset_required_fields(query_params)) + default_values = _Base{{ service.name }}RestTransport._Base{{method.name}}._Base{{method.name}}__REQUIRED_FIELDS_DEFAULT_VALUES + query_params.update({k: v for k, v in default_values.items() if k not in query_params}) {% endif %}{# required fields #} {% if opts.rest_numeric_enums %} diff --git a/packages/gapic-generator/gapic/ads-templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 b/packages/gapic-generator/gapic/ads-templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 index 6c051147f937..613a37b06080 100644 --- a/packages/gapic-generator/gapic/ads-templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 +++ b/packages/gapic-generator/gapic/ads-templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 @@ -1339,7 +1339,12 @@ def test_{{ method_name }}_rest_required_fields(request_type={{ method.input.ide assert "{{ field_name }}" not in jsonified_request {% endfor %} - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).{{ method.transport_safe_name | snake_case }}._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._Base{{ method.name }}, + "_Base{{ method.name }}__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -1355,12 +1360,10 @@ def test_{{ method_name }}_rest_required_fields(request_type={{ method.input.ide jsonified_request["{{ field_name }}"] = {{ mock_value }} {% endfor %} - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).{{ method.transport_safe_name | snake_case }}._get_unset_required_fields(jsonified_request) {% if method.query_params %} # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(({% for param in method.query_params|sort %}"{{param}}", {% endfor %})) + assert not set(unset_fields) - set(({% for param in method.query_params|sort %}"{{param | camel_case}}", {% endfor %})) {% endif %} - jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone {% for req_field in method.input.required_fields if req_field.is_primitive %} @@ -1460,13 +1463,6 @@ def test_{{ method_name }}_rest_required_fields(request_type={{ method.input.ide assert expected_params == actual_params -def test_{{ method_name }}_rest_unset_required_fields(): - transport = transports.{{ service.rest_transport_name }}(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.{{ method.transport_safe_name|snake_case }}._get_unset_required_fields({}) - assert set(unset_fields) == (set(({% for param in method.query_params|sort %}"{{ param|camel_case }}", {% endfor %})) & set(({% for param in method.input.required_fields %}"{{param.name|camel_case}}", {% endfor %}))) - - {% endif %}{# required_fields #} {% if not method.client_streaming %} diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 index f9fa334ef284..fb184e722174 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/_compat.py.j2 @@ -13,15 +13,24 @@ falling back to the local implementation if not present. #} {# TODO(https://github.com/googleapis/google-cloud-python/issues/17883): Backfill compatibility functions being removed from the client layer. #} -from typing import Optional +import json +{% if has_auto_populated_fields %} +import uuid +{% endif %} + +from typing import Any, Dict, List, Optional, Tuple +{% if has_auto_populated_fields %} +from typing import Union +{% endif %} + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError from google.api_core.universe import EmptyUniverseError {% if has_auto_populated_fields %} -import uuid -from typing import Union import google.protobuf.message {% endif %} @@ -189,4 +198,62 @@ def setup_request_id( setattr(request, field_name, str(uuid.uuid4())) {% endif %} + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json + {% endblock %} diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 index 730c1fe7d8b1..e39425bb8117 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 @@ -194,22 +194,24 @@ def _get_http_options(): service: The service. is_async (bool): Used to determine the code path i.e. whether for sync or async call. is_request_message_proto_plus_type (bool): Used to determine whether the request message is a proto-plus type. #} -{% macro rest_call_method_common(body_spec, method_name, service, is_async=False, is_request_message_proto_plus_type=False) %} +{% macro rest_call_method_common(body_spec, method_name, service, is_async=False, is_request_message_proto_plus_type=False, rest_numeric_enums=False) %} {% set service_name = service.name %} {% set await_prefix = "await " if is_async else "" %} {% set async_class_prefix = "Async" if is_async else "" %} http_options = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_http_options() - {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2274): Add debug log before intercepting a request #} + {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2274): Add debug log before intercepting a request #} request, metadata = {{ await_prefix }}self._interceptor.pre_{{ method_name|snake_case }}(request, metadata) - transcoded_request = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_transcoded_request(http_options, request) - - {% if body_spec %} - body = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_request_body_json(transcoded_request) - {% endif %}{# body_spec #} - - # Jsonify the query params - query_params = _Base{{ service_name }}RestTransport._Base{{method_name}}._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _Base{{ service_name }}RestTransport._Base{{method_name}}, + "_Base{{method_name}}__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums={{ rest_numeric_enums }}, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 index 16cc77ea937c..97aa76bff7b7 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/_rest_mixins_base.py.j2 @@ -25,27 +25,5 @@ {{ shared_macros.http_options_method(api.mixin_http_options["{}".format(name)])|indent(8)}} - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - {% set body_spec = api.mixin_http_options["{}".format(name)][0].body %} - {%- if body_spec %} - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - - {%- endif %} {# body_spec #} - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - {% endfor %} {% endif %} {# rest in opts.transport #} diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 index 49c1374053b5..1bc499c068ee 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 @@ -13,6 +13,8 @@ from google.api_core import retry as retries from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +{% set package_path = api.naming.module_namespace|join('.') + "." + api.naming.versioned_module_name %} +from {{package_path}}._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -245,7 +247,7 @@ class {{service.name}}RestTransport(_Base{{ service.name }}RestTransport): {% endif %} """ - {{ shared_macros.rest_call_method_common(body_spec, method.name, service, False, method.input.ident.is_proto_plus_type)|indent(8) }} + {{ shared_macros.rest_call_method_common(body_spec, method.name, service, False, method.input.ident.is_proto_plus_type, opts.rest_numeric_enums)|indent(8) }} {% if not method.void %} # Return the response diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 index 80980572c30a..0f79d6e1ffef 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 @@ -34,6 +34,9 @@ from google.cloud.location import locations_pb2 # type: ignore from google.api_core import retry_async as retries from google.api_core import rest_helpers from google.api_core import rest_streaming_async # type: ignore +{% set package_path = api.naming.module_namespace|join('.') + "." + api.naming.versioned_module_name %} +from {{package_path}}._compat import transcode_request + import google.protobuf from google.protobuf import json_format @@ -203,7 +206,7 @@ class Async{{service.name}}RestTransport(_Base{{ service.name }}RestTransport): {% endif %} """ - {{ shared_macros.rest_call_method_common(body_spec, method.name, service, True, method.input.ident.is_proto_plus_type)|indent(8) }} + {{ shared_macros.rest_call_method_common(body_spec, method.name, service, True, method.input.ident.is_proto_plus_type, opts.rest_numeric_enums)|indent(8) }} {% if not method.void %} # Return the response diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 index b79785afc517..08887c16eb51 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_base.py.j2 @@ -116,55 +116,11 @@ class _Base{{ service.name }}RestTransport({{service.name}}Transport): {% endfor %} } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} {% endif %}{# required fields #} - + {% set method_http_options = method.http_options %} - - {{ shared_macros.http_options_method(method_http_options)|indent(8) }} - - @staticmethod - def _get_transcoded_request(http_options, request): - {% if method.input.ident.is_proto_plus_type %} - pb_request = {{method.input.ident}}.pb(request) - {% else %} - pb_request = request - {% endif %} - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - {% set body_spec = method.http_options[0].body %} - {%- if body_spec %} - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums={{ opts.rest_numeric_enums }} - ) - return body - - {%- endif %}{# body_spec #} - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums={{ opts.rest_numeric_enums }}, - )) - {% if method.input.required_fields %} - query_params.update(_Base{{ service.name }}RestTransport._Base{{method.name}}._get_unset_required_fields(query_params)) - {% endif %}{# required fields #} - - {% if opts.rest_numeric_enums %} - query_params["$alt"] = "json;enum-encoding=int" - {% endif %} - return query_params + {{ shared_macros.http_options_method(method_http_options)|indent(8) }} {% endif %}{# method.http_options and not method.client_streaming #} {% endfor %} diff --git a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_compat.py.j2 b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_compat.py.j2 index aa45d0656c85..a047c589f80f 100644 --- a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_compat.py.j2 +++ b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_compat.py.j2 @@ -10,10 +10,18 @@ google-api-core has the functions in `_compat.py.j2`. #} {# TODO(https://github.com/googleapis/google-cloud-python/issues/17883): Backfill compatibility functions tests being removed from the client layer. #} -import re +import json import pytest +{% if has_auto_populated_fields %} +import re +{% endif %} + +from unittest import mock + +from google.protobuf import descriptor_pb2 {% set package_path = api.naming.module_namespace|join('.') + "." + api.naming.versioned_module_name %} +from {{package_path}}._compat import transcode_request from {{package_path}} import _compat as universe {% if has_auto_populated_fields %} from {{package_path}}._compat import setup_request_id @@ -301,4 +309,177 @@ def test_setup_request_id(request_obj, is_proto3_optional, expected): assert value == expected {% endif %} + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" + {% endblock %} diff --git a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_macros.j2 b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_macros.j2 index 982b2fb19b44..05c60cbdc9c3 100644 --- a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_macros.j2 +++ b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_macros.j2 @@ -1101,7 +1101,12 @@ def test_{{ method_name }}_rest_required_fields(request_type={{ method.input.ide assert "{{ field_name }}" not in jsonified_request {% endfor %} - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).{{ method.transport_safe_name | snake_case }}._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._Base{{ method.name }}, + "_Base{{ method.name }}__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -1117,12 +1122,10 @@ def test_{{ method_name }}_rest_required_fields(request_type={{ method.input.ide jsonified_request["{{ field_name }}"] = {{ mock_value }} {% endfor %} - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).{{ method.transport_safe_name | snake_case }}._get_unset_required_fields(jsonified_request) {% if method.query_params %} # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(({% for param in method.query_params|sort %}"{{param}}", {% endfor %})) + assert not set(unset_fields) - set(({% for param in method.query_params|sort %}"{{param | camel_case}}", {% endfor %})) {% endif %} - jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone {% for req_field in method.input.required_fields if req_field.is_primitive %} @@ -1239,13 +1242,6 @@ def test_{{ method_name }}_rest_required_fields(request_type={{ method.input.ide actual_params = req.call_args.kwargs['params'] assert sorted(expected_params) == sorted(actual_params) - -def test_{{ method_name }}_rest_unset_required_fields(): - transport = transports.{{ service.rest_transport_name }}(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.{{ method.transport_safe_name|snake_case }}._get_unset_required_fields({}) - assert set(unset_fields) == (set(({% for param in method.query_params|sort %}"{{ param|camel_case }}", {% endfor %})) & set(({% for param in method.input.required_fields %}"{{ param.name|camel_case }}", {% endfor %}))) - {% endif %}{# required_fields #} diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py index a9a4b4693298..d85aa16473c2 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +from google.cloud.asset_v1._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -1235,12 +1236,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_http_options() - request, metadata = self._interceptor.pre_analyze_iam_policy(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy, + "_BaseAnalyzeIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1360,14 +1366,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_http_options() - request, metadata = self._interceptor.pre_analyze_iam_policy_longrunning(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning, + "_BaseAnalyzeIamPolicyLongrunning__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1482,12 +1491,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeMove._get_http_options() - request, metadata = self._interceptor.pre_analyze_move(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeMove._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeMove._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeMove, + "_BaseAnalyzeMove__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1604,12 +1618,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_http_options() - request, metadata = self._interceptor.pre_analyze_org_policies(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies, + "_BaseAnalyzeOrgPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1727,12 +1746,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_http_options() - request, metadata = self._interceptor.pre_analyze_org_policy_governed_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets, + "_BaseAnalyzeOrgPolicyGovernedAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1850,12 +1874,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_http_options() - request, metadata = self._interceptor.pre_analyze_org_policy_governed_containers(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers, + "_BaseAnalyzeOrgPolicyGovernedContainers__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1969,12 +1998,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_http_options() - request, metadata = self._interceptor.pre_batch_get_assets_history(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory, + "_BaseBatchGetAssetsHistory__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2092,12 +2126,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_http_options() - request, metadata = self._interceptor.pre_batch_get_effective_iam_policies(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies, + "_BaseBatchGetEffectiveIamPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2220,14 +2259,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseCreateFeed._get_http_options() - request, metadata = self._interceptor.pre_create_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseCreateFeed._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseCreateFeed._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseCreateFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseCreateFeed, + "_BaseCreateFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2344,14 +2386,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_create_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseCreateSavedQuery, + "_BaseCreateSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2461,12 +2506,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseDeleteFeed._get_http_options() - request, metadata = self._interceptor.pre_delete_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseDeleteFeed._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseDeleteFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseDeleteFeed, + "_BaseDeleteFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2546,12 +2596,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_delete_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseDeleteSavedQuery, + "_BaseDeleteSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2639,14 +2694,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseExportAssets._get_http_options() - request, metadata = self._interceptor.pre_export_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseExportAssets._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseExportAssets._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseExportAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseExportAssets, + "_BaseExportAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2766,12 +2824,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseGetFeed._get_http_options() - request, metadata = self._interceptor.pre_get_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseGetFeed._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseGetFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseGetFeed, + "_BaseGetFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2887,12 +2950,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseGetSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_get_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseGetSavedQuery._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseGetSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseGetSavedQuery, + "_BaseGetSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3006,12 +3074,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseListAssets._get_http_options() - request, metadata = self._interceptor.pre_list_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseListAssets._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseListAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseListAssets, + "_BaseListAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3125,12 +3198,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseListFeeds._get_http_options() - request, metadata = self._interceptor.pre_list_feeds(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseListFeeds._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseListFeeds._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseListFeeds, + "_BaseListFeeds__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3244,12 +3322,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseListSavedQueries._get_http_options() - request, metadata = self._interceptor.pre_list_saved_queries(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseListSavedQueries._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseListSavedQueries._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseListSavedQueries, + "_BaseListSavedQueries__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3364,14 +3447,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseQueryAssets._get_http_options() - request, metadata = self._interceptor.pre_query_assets(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseQueryAssets._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseQueryAssets._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseQueryAssets._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseQueryAssets, + "_BaseQueryAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3485,12 +3571,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_http_options() - request, metadata = self._interceptor.pre_search_all_iam_policies(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseSearchAllIamPolicies, + "_BaseSearchAllIamPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3604,12 +3695,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseSearchAllResources._get_http_options() - request, metadata = self._interceptor.pre_search_all_resources(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseSearchAllResources._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseSearchAllResources._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseSearchAllResources, + "_BaseSearchAllResources__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3732,14 +3828,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_http_options() - request, metadata = self._interceptor.pre_update_feed(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseUpdateFeed._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseUpdateFeed, + "_BaseUpdateFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3856,14 +3955,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_http_options() - request, metadata = self._interceptor.pre_update_saved_query(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_transcoded_request(http_options, request) - - body = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseUpdateSavedQuery, + "_BaseUpdateSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4165,12 +4267,17 @@ def __call__(self, """ http_options = _BaseAssetServiceRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseAssetServiceRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseAssetServiceRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseAssetServiceRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py index f635d0015fee..b5b30671d1fb 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest_base.py @@ -94,10 +94,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "analysisQuery" : {}, } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -107,22 +103,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeIamPolicyRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeIamPolicy._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeIamPolicyLongrunning: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -130,10 +110,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -144,31 +120,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeIamPolicyLongrunningRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeIamPolicyLongrunning._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeMove: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -176,10 +127,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "destinationParent" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -189,22 +136,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeMoveRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeMove._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeOrgPolicies: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -212,10 +143,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "constraint" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -225,22 +152,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeOrgPoliciesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicies._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeOrgPolicyGovernedAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -248,10 +159,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "constraint" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -261,22 +168,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeOrgPolicyGovernedAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseAnalyzeOrgPolicyGovernedContainers: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -284,10 +175,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "constraint" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -297,22 +184,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.AnalyzeOrgPolicyGovernedContainersRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseAnalyzeOrgPolicyGovernedContainers._get_unset_required_fields(query_params)) - - return query_params - class _BaseBatchGetAssetsHistory: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -320,10 +191,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -333,22 +200,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.BatchGetAssetsHistoryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseBatchGetAssetsHistory._get_unset_required_fields(query_params)) - - return query_params - class _BaseBatchGetEffectiveIamPolicies: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -356,10 +207,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "names" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -369,22 +216,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.BatchGetEffectiveIamPoliciesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseBatchGetEffectiveIamPolicies._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -392,10 +223,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -406,31 +233,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.CreateFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseCreateFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -438,10 +240,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "savedQueryId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -452,31 +250,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.CreateSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseCreateSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -484,10 +257,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -497,22 +266,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.DeleteFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseDeleteFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -520,10 +273,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -533,22 +282,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.DeleteSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseDeleteSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseExportAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -556,10 +289,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -570,31 +299,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ExportAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseExportAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -602,10 +306,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -615,22 +315,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.GetFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseGetFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -638,10 +322,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -651,22 +331,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.GetSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseGetSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseListAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -674,10 +338,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -687,22 +347,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ListAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseListAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseListFeeds: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -710,10 +354,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -723,22 +363,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ListFeedsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseListFeeds._get_unset_required_fields(query_params)) - - return query_params - class _BaseListSavedQueries: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -746,10 +370,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -759,22 +379,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.ListSavedQueriesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseListSavedQueries._get_unset_required_fields(query_params)) - - return query_params - class _BaseQueryAssets: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -782,10 +386,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -796,31 +396,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.QueryAssetsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseQueryAssets._get_unset_required_fields(query_params)) - - return query_params - class _BaseSearchAllIamPolicies: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -828,10 +403,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -841,22 +412,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.SearchAllIamPoliciesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseSearchAllIamPolicies._get_unset_required_fields(query_params)) - - return query_params - class _BaseSearchAllResources: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -864,10 +419,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -877,22 +428,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.SearchAllResourcesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseSearchAllResources._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateFeed: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -900,10 +435,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -914,31 +445,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.UpdateFeedRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseUpdateFeed._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateSavedQuery: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -946,10 +452,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "updateMask" : {}, } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -960,31 +462,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = asset_service.UpdateSavedQueryRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseAssetServiceRestTransport._BaseUpdateSavedQuery._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -998,18 +475,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseAssetServiceRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py index 52913c13552b..1f3cf14e43db 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py @@ -9158,16 +9158,18 @@ def test_export_assets_rest_required_fields(request_type=asset_service.ExportAss # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).export_assets._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseExportAssets, + "_BaseExportAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).export_assets._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "parent" in jsonified_request assert jsonified_request["parent"] == 'parent_value' @@ -9213,13 +9215,6 @@ def test_export_assets_rest_required_fields(request_type=asset_service.ExportAss assert sorted(expected_params) == sorted(actual_params) -def test_export_assets_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.export_assets._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("parent", "outputConfig", ))) - - def test_list_assets_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -9268,17 +9263,20 @@ def test_list_assets_rest_required_fields(request_type=asset_service.ListAssetsR # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_assets._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListAssets, + "_BaseListAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_assets._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("asset_types", "content_type", "page_size", "page_token", "read_time", "relationship_types", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("assetTypes", "contentType", "pageSize", "pageToken", "readTime", "relationshipTypes", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -9327,13 +9325,6 @@ def test_list_assets_rest_required_fields(request_type=asset_service.ListAssetsR assert sorted(expected_params) == sorted(actual_params) -def test_list_assets_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_assets._get_unset_required_fields({}) - assert set(unset_fields) == (set(("assetTypes", "contentType", "pageSize", "pageToken", "readTime", "relationshipTypes", )) & set(("parent", ))) - - def test_list_assets_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -9501,17 +9492,20 @@ def test_batch_get_assets_history_rest_required_fields(request_type=asset_servic # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).batch_get_assets_history._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseBatchGetAssetsHistory, + "_BaseBatchGetAssetsHistory__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).batch_get_assets_history._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("asset_names", "content_type", "read_time_window", "relationship_types", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("assetNames", "contentType", "readTimeWindow", "relationshipTypes", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -9560,13 +9554,6 @@ def test_batch_get_assets_history_rest_required_fields(request_type=asset_servic assert sorted(expected_params) == sorted(actual_params) -def test_batch_get_assets_history_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.batch_get_assets_history._get_unset_required_fields({}) - assert set(unset_fields) == (set(("assetNames", "contentType", "readTimeWindow", "relationshipTypes", )) & set(("parent", ))) - - def test_create_feed_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -9616,7 +9603,12 @@ def test_create_feed_rest_required_fields(request_type=asset_service.CreateFeedR # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_feed._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateFeed, + "_BaseCreateFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -9624,9 +9616,6 @@ def test_create_feed_rest_required_fields(request_type=asset_service.CreateFeedR jsonified_request["parent"] = 'parent_value' jsonified_request["feedId"] = 'feed_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_feed._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "parent" in jsonified_request assert jsonified_request["parent"] == 'parent_value' @@ -9677,13 +9666,6 @@ def test_create_feed_rest_required_fields(request_type=asset_service.CreateFeedR assert sorted(expected_params) == sorted(actual_params) -def test_create_feed_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_feed._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("parent", "feedId", "feed", ))) - - def test_create_feed_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -9786,16 +9768,18 @@ def test_get_feed_rest_required_fields(request_type=asset_service.GetFeedRequest # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_feed._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetFeed, + "_BaseGetFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_feed._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -9843,13 +9827,6 @@ def test_get_feed_rest_required_fields(request_type=asset_service.GetFeedRequest assert sorted(expected_params) == sorted(actual_params) -def test_get_feed_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_feed._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_feed_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -9952,16 +9929,18 @@ def test_list_feeds_rest_required_fields(request_type=asset_service.ListFeedsReq # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_feeds._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListFeeds, + "_BaseListFeeds__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_feeds._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "parent" in jsonified_request assert jsonified_request["parent"] == 'parent_value' @@ -10009,13 +9988,6 @@ def test_list_feeds_rest_required_fields(request_type=asset_service.ListFeedsReq assert sorted(expected_params) == sorted(actual_params) -def test_list_feeds_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_feeds._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("parent", ))) - - def test_list_feeds_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -10117,14 +10089,16 @@ def test_update_feed_rest_required_fields(request_type=asset_service.UpdateFeedR # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_feed._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateFeed, + "_BaseUpdateFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_feed._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone client = AssetServiceClient( @@ -10171,13 +10145,6 @@ def test_update_feed_rest_required_fields(request_type=asset_service.UpdateFeedR assert sorted(expected_params) == sorted(actual_params) -def test_update_feed_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_feed._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("feed", "updateMask", ))) - - def test_update_feed_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -10280,16 +10247,18 @@ def test_delete_feed_rest_required_fields(request_type=asset_service.DeleteFeedR # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_feed._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteFeed, + "_BaseDeleteFeed__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_feed._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -10334,13 +10303,6 @@ def test_delete_feed_rest_required_fields(request_type=asset_service.DeleteFeedR assert sorted(expected_params) == sorted(actual_params) -def test_delete_feed_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_feed._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_delete_feed_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -10441,17 +10403,20 @@ def test_search_all_resources_rest_required_fields(request_type=asset_service.Se # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).search_all_resources._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseSearchAllResources, + "_BaseSearchAllResources__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["scope"] = 'scope_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).search_all_resources._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("asset_types", "order_by", "page_size", "page_token", "query", "read_mask", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("assetTypes", "orderBy", "pageSize", "pageToken", "query", "readMask", )) # verify required fields with non-default values are left alone assert "scope" in jsonified_request @@ -10500,13 +10465,6 @@ def test_search_all_resources_rest_required_fields(request_type=asset_service.Se assert sorted(expected_params) == sorted(actual_params) -def test_search_all_resources_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.search_all_resources._get_unset_required_fields({}) - assert set(unset_fields) == (set(("assetTypes", "orderBy", "pageSize", "pageToken", "query", "readMask", )) & set(("scope", ))) - - def test_search_all_resources_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -10678,17 +10636,20 @@ def test_search_all_iam_policies_rest_required_fields(request_type=asset_service # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).search_all_iam_policies._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseSearchAllIamPolicies, + "_BaseSearchAllIamPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["scope"] = 'scope_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).search_all_iam_policies._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("asset_types", "order_by", "page_size", "page_token", "query", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("assetTypes", "orderBy", "pageSize", "pageToken", "query", )) # verify required fields with non-default values are left alone assert "scope" in jsonified_request @@ -10737,13 +10698,6 @@ def test_search_all_iam_policies_rest_required_fields(request_type=asset_service assert sorted(expected_params) == sorted(actual_params) -def test_search_all_iam_policies_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.search_all_iam_policies._get_unset_required_fields({}) - assert set(unset_fields) == (set(("assetTypes", "orderBy", "pageSize", "pageToken", "query", )) & set(("scope", ))) - - def test_search_all_iam_policies_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -10912,15 +10866,18 @@ def test_analyze_iam_policy_rest_required_fields(request_type=asset_service.Anal # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_iam_policy._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseAnalyzeIamPolicy, + "_BaseAnalyzeIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_iam_policy._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("analysis_query", "execution_timeout", "saved_analysis_query", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("analysisQuery", "executionTimeout", "savedAnalysisQuery", )) # verify required fields with non-default values are left alone @@ -10967,13 +10924,6 @@ def test_analyze_iam_policy_rest_required_fields(request_type=asset_service.Anal assert sorted(expected_params) == sorted(actual_params) -def test_analyze_iam_policy_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.analyze_iam_policy._get_unset_required_fields({}) - assert set(unset_fields) == (set(("analysisQuery", "executionTimeout", "savedAnalysisQuery", )) & set(("analysisQuery", ))) - - def test_analyze_iam_policy_longrunning_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -11025,14 +10975,16 @@ def test_analyze_iam_policy_longrunning_rest_required_fields(request_type=asset_ # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_iam_policy_longrunning._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseAnalyzeIamPolicyLongrunning, + "_BaseAnalyzeIamPolicyLongrunning__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_iam_policy_longrunning._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone client = AssetServiceClient( @@ -11076,13 +11028,6 @@ def test_analyze_iam_policy_longrunning_rest_required_fields(request_type=asset_ assert sorted(expected_params) == sorted(actual_params) -def test_analyze_iam_policy_longrunning_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.analyze_iam_policy_longrunning._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("analysisQuery", "outputConfig", ))) - - def test_analyze_move_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -11133,7 +11078,12 @@ def test_analyze_move_rest_required_fields(request_type=asset_service.AnalyzeMov # verify fields with default values are dropped assert "destinationParent" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_move._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseAnalyzeMove, + "_BaseAnalyzeMove__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -11143,10 +11093,8 @@ def test_analyze_move_rest_required_fields(request_type=asset_service.AnalyzeMov jsonified_request["resource"] = 'resource_value' jsonified_request["destinationParent"] = 'destination_parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_move._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("destination_parent", "view", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("destinationParent", "view", )) # verify required fields with non-default values are left alone assert "resource" in jsonified_request @@ -11201,13 +11149,6 @@ def test_analyze_move_rest_required_fields(request_type=asset_service.AnalyzeMov assert sorted(expected_params) == sorted(actual_params) -def test_analyze_move_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.analyze_move._get_unset_required_fields({}) - assert set(unset_fields) == (set(("destinationParent", "view", )) & set(("resource", "destinationParent", ))) - - def test_query_assets_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -11256,16 +11197,18 @@ def test_query_assets_rest_required_fields(request_type=asset_service.QueryAsset # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).query_assets._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseQueryAssets, + "_BaseQueryAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).query_assets._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "parent" in jsonified_request assert jsonified_request["parent"] == 'parent_value' @@ -11314,13 +11257,6 @@ def test_query_assets_rest_required_fields(request_type=asset_service.QueryAsset assert sorted(expected_params) == sorted(actual_params) -def test_query_assets_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.query_assets._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("parent", ))) - - def test_create_saved_query_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -11371,7 +11307,12 @@ def test_create_saved_query_rest_required_fields(request_type=asset_service.Crea # verify fields with default values are dropped assert "savedQueryId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_saved_query._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateSavedQuery, + "_BaseCreateSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -11381,10 +11322,8 @@ def test_create_saved_query_rest_required_fields(request_type=asset_service.Crea jsonified_request["parent"] = 'parent_value' jsonified_request["savedQueryId"] = 'saved_query_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_saved_query._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("saved_query_id", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("savedQueryId", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -11440,13 +11379,6 @@ def test_create_saved_query_rest_required_fields(request_type=asset_service.Crea assert sorted(expected_params) == sorted(actual_params) -def test_create_saved_query_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_saved_query._get_unset_required_fields({}) - assert set(unset_fields) == (set(("savedQueryId", )) & set(("parent", "savedQuery", "savedQueryId", ))) - - def test_create_saved_query_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11553,16 +11485,18 @@ def test_get_saved_query_rest_required_fields(request_type=asset_service.GetSave # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_saved_query._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetSavedQuery, + "_BaseGetSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_saved_query._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -11610,13 +11544,6 @@ def test_get_saved_query_rest_required_fields(request_type=asset_service.GetSave assert sorted(expected_params) == sorted(actual_params) -def test_get_saved_query_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_saved_query._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_saved_query_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11719,17 +11646,20 @@ def test_list_saved_queries_rest_required_fields(request_type=asset_service.List # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_saved_queries._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListSavedQueries, + "_BaseListSavedQueries__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_saved_queries._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -11778,13 +11708,6 @@ def test_list_saved_queries_rest_required_fields(request_type=asset_service.List assert sorted(expected_params) == sorted(actual_params) -def test_list_saved_queries_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_saved_queries._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_saved_queries_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11951,15 +11874,18 @@ def test_update_saved_query_rest_required_fields(request_type=asset_service.Upda # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_saved_query._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateSavedQuery, + "_BaseUpdateSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_saved_query._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("updateMask", )) # verify required fields with non-default values are left alone @@ -12007,13 +11933,6 @@ def test_update_saved_query_rest_required_fields(request_type=asset_service.Upda assert sorted(expected_params) == sorted(actual_params) -def test_update_saved_query_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_saved_query._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask", )) & set(("savedQuery", "updateMask", ))) - - def test_update_saved_query_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12118,16 +12037,18 @@ def test_delete_saved_query_rest_required_fields(request_type=asset_service.Dele # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_saved_query._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteSavedQuery, + "_BaseDeleteSavedQuery__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_saved_query._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -12172,13 +12093,6 @@ def test_delete_saved_query_rest_required_fields(request_type=asset_service.Dele assert sorted(expected_params) == sorted(actual_params) -def test_delete_saved_query_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_saved_query._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_delete_saved_query_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12281,7 +12195,12 @@ def test_batch_get_effective_iam_policies_rest_required_fields(request_type=asse # verify fields with default values are dropped assert "names" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).batch_get_effective_iam_policies._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseBatchGetEffectiveIamPolicies, + "_BaseBatchGetEffectiveIamPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12291,10 +12210,8 @@ def test_batch_get_effective_iam_policies_rest_required_fields(request_type=asse jsonified_request["scope"] = 'scope_value' jsonified_request["names"] = 'names_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).batch_get_effective_iam_policies._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set(("names", )) - jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone assert "scope" in jsonified_request @@ -12349,13 +12266,6 @@ def test_batch_get_effective_iam_policies_rest_required_fields(request_type=asse assert sorted(expected_params) == sorted(actual_params) -def test_batch_get_effective_iam_policies_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.batch_get_effective_iam_policies._get_unset_required_fields({}) - assert set(unset_fields) == (set(("names", )) & set(("scope", "names", ))) - - def test_analyze_org_policies_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -12406,7 +12316,12 @@ def test_analyze_org_policies_rest_required_fields(request_type=asset_service.An # verify fields with default values are dropped assert "constraint" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_org_policies._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseAnalyzeOrgPolicies, + "_BaseAnalyzeOrgPolicies__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12416,10 +12331,8 @@ def test_analyze_org_policies_rest_required_fields(request_type=asset_service.An jsonified_request["scope"] = 'scope_value' jsonified_request["constraint"] = 'constraint_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_org_policies._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("constraint", "filter", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("constraint", "filter", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "scope" in jsonified_request @@ -12474,13 +12387,6 @@ def test_analyze_org_policies_rest_required_fields(request_type=asset_service.An assert sorted(expected_params) == sorted(actual_params) -def test_analyze_org_policies_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.analyze_org_policies._get_unset_required_fields({}) - assert set(unset_fields) == (set(("constraint", "filter", "pageSize", "pageToken", )) & set(("scope", "constraint", ))) - - def test_analyze_org_policies_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12654,7 +12560,12 @@ def test_analyze_org_policy_governed_containers_rest_required_fields(request_typ # verify fields with default values are dropped assert "constraint" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_org_policy_governed_containers._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseAnalyzeOrgPolicyGovernedContainers, + "_BaseAnalyzeOrgPolicyGovernedContainers__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12664,10 +12575,8 @@ def test_analyze_org_policy_governed_containers_rest_required_fields(request_typ jsonified_request["scope"] = 'scope_value' jsonified_request["constraint"] = 'constraint_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_org_policy_governed_containers._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("constraint", "filter", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("constraint", "filter", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "scope" in jsonified_request @@ -12722,13 +12631,6 @@ def test_analyze_org_policy_governed_containers_rest_required_fields(request_typ assert sorted(expected_params) == sorted(actual_params) -def test_analyze_org_policy_governed_containers_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.analyze_org_policy_governed_containers._get_unset_required_fields({}) - assert set(unset_fields) == (set(("constraint", "filter", "pageSize", "pageToken", )) & set(("scope", "constraint", ))) - - def test_analyze_org_policy_governed_containers_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12902,7 +12804,12 @@ def test_analyze_org_policy_governed_assets_rest_required_fields(request_type=as # verify fields with default values are dropped assert "constraint" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_org_policy_governed_assets._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseAnalyzeOrgPolicyGovernedAssets, + "_BaseAnalyzeOrgPolicyGovernedAssets__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12912,10 +12819,8 @@ def test_analyze_org_policy_governed_assets_rest_required_fields(request_type=as jsonified_request["scope"] = 'scope_value' jsonified_request["constraint"] = 'constraint_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).analyze_org_policy_governed_assets._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("constraint", "filter", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("constraint", "filter", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "scope" in jsonified_request @@ -12970,13 +12875,6 @@ def test_analyze_org_policy_governed_assets_rest_required_fields(request_type=as assert sorted(expected_params) == sorted(actual_params) -def test_analyze_org_policy_governed_assets_rest_unset_required_fields(): - transport = transports.AssetServiceRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.analyze_org_policy_governed_assets._get_unset_required_fields({}) - assert set(unset_fields) == (set(("constraint", "filter", "pageSize", "pageToken", )) & set(("scope", "constraint", ))) - - def test_analyze_org_policy_governed_assets_rest_flattened(): client = AssetServiceClient( credentials=ga_credentials.AnonymousCredentials(), diff --git a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_compat.py b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_compat.py index 17fbdd221973..7b915c13a3ae 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.cloud.asset_v1._compat import transcode_request from google.cloud.asset_v1 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py index f4969132838a..0cffb09641ed 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +from google.iam.credentials_v1._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -414,14 +415,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_http_options() - request, metadata = self._interceptor.pre_generate_access_token(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseGenerateAccessToken, + "_BaseGenerateAccessToken__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -536,14 +540,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_http_options() - request, metadata = self._interceptor.pre_generate_id_token(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseGenerateIdToken, + "_BaseGenerateIdToken__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -658,14 +665,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_http_options() - request, metadata = self._interceptor.pre_sign_blob(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseSignBlob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseSignBlob, + "_BaseSignBlob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -780,14 +790,17 @@ def __call__(self, """ http_options = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_http_options() - request, metadata = self._interceptor.pre_sign_jwt(request, metadata) - transcoded_request = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_transcoded_request(http_options, request) - - body = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseIAMCredentialsRestTransport._BaseSignJwt._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseIAMCredentialsRestTransport._BaseSignJwt, + "_BaseSignJwt__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py index db587944901a..3c578f3f8485 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest_base.py @@ -92,10 +92,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -106,31 +102,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.GenerateAccessTokenRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseGenerateAccessToken._get_unset_required_fields(query_params)) - - return query_params - class _BaseGenerateIdToken: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -138,10 +109,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -152,31 +119,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.GenerateIdTokenRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseGenerateIdToken._get_unset_required_fields(query_params)) - - return query_params - class _BaseSignBlob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -184,10 +126,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -198,31 +136,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.SignBlobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseSignBlob._get_unset_required_fields(query_params)) - - return query_params - class _BaseSignJwt: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -230,10 +143,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -244,31 +153,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = common.SignJwtRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseIAMCredentialsRestTransport._BaseSignJwt._get_unset_required_fields(query_params)) - - return query_params - __all__=( '_BaseIAMCredentialsRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_compat.py b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_compat.py index 05cb91c594eb..616fd15621c0 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.iam.credentials_v1._compat import transcode_request from google.iam.credentials_v1 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py index 50f68c77ce2d..19dcd4d5d2d6 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py @@ -2327,7 +2327,12 @@ def test_generate_access_token_rest_required_fields(request_type=common.Generate # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).generate_access_token._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGenerateAccessToken, + "_BaseGenerateAccessToken__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -2335,9 +2340,6 @@ def test_generate_access_token_rest_required_fields(request_type=common.Generate jsonified_request["name"] = 'name_value' jsonified_request["scope"] = 'scope_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).generate_access_token._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -2388,13 +2390,6 @@ def test_generate_access_token_rest_required_fields(request_type=common.Generate assert sorted(expected_params) == sorted(actual_params) -def test_generate_access_token_rest_unset_required_fields(): - transport = transports.IAMCredentialsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.generate_access_token._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "scope", ))) - - def test_generate_access_token_rest_flattened(): client = IAMCredentialsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2504,7 +2499,12 @@ def test_generate_id_token_rest_required_fields(request_type=common.GenerateIdTo # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).generate_id_token._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGenerateIdToken, + "_BaseGenerateIdToken__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -2512,9 +2512,6 @@ def test_generate_id_token_rest_required_fields(request_type=common.GenerateIdTo jsonified_request["name"] = 'name_value' jsonified_request["audience"] = 'audience_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).generate_id_token._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -2565,13 +2562,6 @@ def test_generate_id_token_rest_required_fields(request_type=common.GenerateIdTo assert sorted(expected_params) == sorted(actual_params) -def test_generate_id_token_rest_unset_required_fields(): - transport = transports.IAMCredentialsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.generate_id_token._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "audience", ))) - - def test_generate_id_token_rest_flattened(): client = IAMCredentialsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2681,7 +2671,12 @@ def test_sign_blob_rest_required_fields(request_type=common.SignBlobRequest): # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).sign_blob._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseSignBlob, + "_BaseSignBlob__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -2689,9 +2684,6 @@ def test_sign_blob_rest_required_fields(request_type=common.SignBlobRequest): jsonified_request["name"] = 'name_value' jsonified_request["payload"] = b'payload_blob' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).sign_blob._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -2742,13 +2734,6 @@ def test_sign_blob_rest_required_fields(request_type=common.SignBlobRequest): assert sorted(expected_params) == sorted(actual_params) -def test_sign_blob_rest_unset_required_fields(): - transport = transports.IAMCredentialsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.sign_blob._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "payload", ))) - - def test_sign_blob_rest_flattened(): client = IAMCredentialsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2856,7 +2841,12 @@ def test_sign_jwt_rest_required_fields(request_type=common.SignJwtRequest): # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).sign_jwt._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseSignJwt, + "_BaseSignJwt__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -2864,9 +2854,6 @@ def test_sign_jwt_rest_required_fields(request_type=common.SignJwtRequest): jsonified_request["name"] = 'name_value' jsonified_request["payload"] = 'payload_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).sign_jwt._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -2917,13 +2904,6 @@ def test_sign_jwt_rest_required_fields(request_type=common.SignJwtRequest): assert sorted(expected_params) == sorted(actual_params) -def test_sign_jwt_rest_unset_required_fields(): - transport = transports.IAMCredentialsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.sign_jwt._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "payload", ))) - - def test_sign_jwt_rest_flattened(): client = IAMCredentialsClient( credentials=ga_credentials.AnonymousCredentials(), diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py index fb9a5c2a8c26..1565671cf8d4 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +from google.cloud.eventarc_v1._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -2206,14 +2207,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateChannel._get_http_options() - request, metadata = self._interceptor.pre_create_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateChannel._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateChannel._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateChannel, + "_BaseCreateChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2330,14 +2334,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_http_options() - request, metadata = self._interceptor.pre_create_channel_connection(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateChannelConnection._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateChannelConnection, + "_BaseCreateChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2454,14 +2461,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateEnrollment._get_http_options() - request, metadata = self._interceptor.pre_create_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateEnrollment._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateEnrollment._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateEnrollment, + "_BaseCreateEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2578,14 +2588,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_create_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateGoogleApiSource, + "_BaseCreateGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2702,14 +2715,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateMessageBus._get_http_options() - request, metadata = self._interceptor.pre_create_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateMessageBus._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateMessageBus._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateMessageBus, + "_BaseCreateMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2826,14 +2842,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreatePipeline._get_http_options() - request, metadata = self._interceptor.pre_create_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreatePipeline._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreatePipeline._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreatePipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreatePipeline, + "_BaseCreatePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2950,14 +2969,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCreateTrigger._get_http_options() - request, metadata = self._interceptor.pre_create_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCreateTrigger._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCreateTrigger._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCreateTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCreateTrigger, + "_BaseCreateTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3073,12 +3095,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteChannel._get_http_options() - request, metadata = self._interceptor.pre_delete_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteChannel._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteChannel, + "_BaseDeleteChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3194,12 +3221,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteChannelConnection._get_http_options() - request, metadata = self._interceptor.pre_delete_channel_connection(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteChannelConnection._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteChannelConnection._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteChannelConnection, + "_BaseDeleteChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3315,12 +3347,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteEnrollment._get_http_options() - request, metadata = self._interceptor.pre_delete_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteEnrollment._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteEnrollment, + "_BaseDeleteEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3436,12 +3473,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_delete_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteGoogleApiSource, + "_BaseDeleteGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3557,12 +3599,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteMessageBus._get_http_options() - request, metadata = self._interceptor.pre_delete_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteMessageBus._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteMessageBus, + "_BaseDeleteMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3678,12 +3725,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeletePipeline._get_http_options() - request, metadata = self._interceptor.pre_delete_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeletePipeline._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeletePipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeletePipeline, + "_BaseDeletePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3799,12 +3851,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteTrigger._get_http_options() - request, metadata = self._interceptor.pre_delete_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteTrigger._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteTrigger, + "_BaseDeleteTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3925,12 +3982,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetChannel._get_http_options() - request, metadata = self._interceptor.pre_get_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetChannel._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetChannel, + "_BaseGetChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4052,12 +4114,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetChannelConnection._get_http_options() - request, metadata = self._interceptor.pre_get_channel_connection(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetChannelConnection._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetChannelConnection._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetChannelConnection, + "_BaseGetChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4178,12 +4245,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetEnrollment._get_http_options() - request, metadata = self._interceptor.pre_get_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetEnrollment._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetEnrollment, + "_BaseGetEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4301,12 +4373,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_get_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetGoogleApiSource._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetGoogleApiSource, + "_BaseGetGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4429,12 +4506,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_http_options() - request, metadata = self._interceptor.pre_get_google_channel_config(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetGoogleChannelConfig, + "_BaseGetGoogleChannelConfig__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4557,12 +4639,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetMessageBus._get_http_options() - request, metadata = self._interceptor.pre_get_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetMessageBus._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetMessageBus, + "_BaseGetMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4679,12 +4766,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetPipeline._get_http_options() - request, metadata = self._interceptor.pre_get_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetPipeline._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetPipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetPipeline, + "_BaseGetPipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4801,12 +4893,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetProvider._get_http_options() - request, metadata = self._interceptor.pre_get_provider(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetProvider._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetProvider._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetProvider, + "_BaseGetProvider__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -4923,12 +5020,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetTrigger._get_http_options() - request, metadata = self._interceptor.pre_get_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetTrigger._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetTrigger, + "_BaseGetTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5045,12 +5147,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListChannelConnections._get_http_options() - request, metadata = self._interceptor.pre_list_channel_connections(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListChannelConnections._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListChannelConnections._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListChannelConnections, + "_BaseListChannelConnections__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5165,12 +5272,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListChannels._get_http_options() - request, metadata = self._interceptor.pre_list_channels(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListChannels._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListChannels._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListChannels, + "_BaseListChannels__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5285,12 +5397,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListEnrollments._get_http_options() - request, metadata = self._interceptor.pre_list_enrollments(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListEnrollments._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListEnrollments._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListEnrollments, + "_BaseListEnrollments__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5407,12 +5524,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListGoogleApiSources._get_http_options() - request, metadata = self._interceptor.pre_list_google_api_sources(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListGoogleApiSources._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListGoogleApiSources._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListGoogleApiSources, + "_BaseListGoogleApiSources__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5530,12 +5652,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_http_options() - request, metadata = self._interceptor.pre_list_message_bus_enrollments(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListMessageBusEnrollments, + "_BaseListMessageBusEnrollments__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5652,12 +5779,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListMessageBuses._get_http_options() - request, metadata = self._interceptor.pre_list_message_buses(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListMessageBuses._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListMessageBuses._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListMessageBuses, + "_BaseListMessageBuses__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5774,12 +5906,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListPipelines._get_http_options() - request, metadata = self._interceptor.pre_list_pipelines(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListPipelines._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListPipelines._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListPipelines, + "_BaseListPipelines__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -5894,12 +6031,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListProviders._get_http_options() - request, metadata = self._interceptor.pre_list_providers(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListProviders._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListProviders._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListProviders, + "_BaseListProviders__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6014,12 +6156,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListTriggers._get_http_options() - request, metadata = self._interceptor.pre_list_triggers(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListTriggers._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListTriggers._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListTriggers, + "_BaseListTriggers__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6138,14 +6285,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateChannel._get_http_options() - request, metadata = self._interceptor.pre_update_channel(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateChannel._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateChannel._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateChannel._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateChannel, + "_BaseUpdateChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6262,14 +6412,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_http_options() - request, metadata = self._interceptor.pre_update_enrollment(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateEnrollment._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateEnrollment, + "_BaseUpdateEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6386,14 +6539,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_http_options() - request, metadata = self._interceptor.pre_update_google_api_source(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateGoogleApiSource, + "_BaseUpdateGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6516,14 +6672,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_http_options() - request, metadata = self._interceptor.pre_update_google_channel_config(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig, + "_BaseUpdateGoogleChannelConfig__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6642,14 +6801,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_http_options() - request, metadata = self._interceptor.pre_update_message_bus(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateMessageBus._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateMessageBus, + "_BaseUpdateMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6766,14 +6928,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdatePipeline._get_http_options() - request, metadata = self._interceptor.pre_update_pipeline(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdatePipeline._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdatePipeline._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdatePipeline._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdatePipeline, + "_BaseUpdatePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -6890,14 +7055,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseUpdateTrigger._get_http_options() - request, metadata = self._interceptor.pre_update_trigger(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseUpdateTrigger._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseUpdateTrigger._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseUpdateTrigger._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseUpdateTrigger, + "_BaseUpdateTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7325,12 +7493,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7443,12 +7616,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7561,12 +7739,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetIamPolicy._get_http_options() - request, metadata = self._interceptor.pre_get_iam_policy(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetIamPolicy._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetIamPolicy._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetIamPolicy, + "_BaseGetIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7680,14 +7863,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseSetIamPolicy._get_http_options() - request, metadata = self._interceptor.pre_set_iam_policy(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseSetIamPolicy._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseSetIamPolicy._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseSetIamPolicy._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseSetIamPolicy, + "_BaseSetIamPolicy__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7801,14 +7987,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseTestIamPermissions._get_http_options() - request, metadata = self._interceptor.pre_test_iam_permissions(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseTestIamPermissions._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseTestIamPermissions._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseTestIamPermissions._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseTestIamPermissions, + "_BaseTestIamPermissions__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -7919,14 +8108,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - body = _BaseEventarcRestTransport._BaseCancelOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -8013,12 +8205,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -8108,12 +8305,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -8226,12 +8428,17 @@ def __call__(self, """ http_options = _BaseEventarcRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseEventarcRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseEventarcRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseEventarcRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py index 0405ac986903..614f97dd14c5 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest_base.py @@ -106,10 +106,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "channelId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -120,31 +116,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateChannel._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateChannelConnection: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -152,10 +123,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "channelConnectionId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -166,31 +133,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateChannelConnectionRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateChannelConnection._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -198,10 +140,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "enrollmentId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -212,31 +150,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -244,10 +157,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "googleApiSourceId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -258,31 +167,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -290,10 +174,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "messageBusId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -304,31 +184,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreatePipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -336,10 +191,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "pipelineId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -350,31 +201,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreatePipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreatePipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -382,10 +208,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "triggerId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -396,31 +218,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.CreateTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseCreateTrigger._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteChannel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -428,10 +225,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -441,22 +234,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteChannel._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteChannelConnection: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -464,10 +241,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -477,22 +250,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteChannelConnectionRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteChannelConnection._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -500,10 +257,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -513,22 +266,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -536,10 +273,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -549,22 +282,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -572,10 +289,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -585,22 +298,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeletePipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -608,10 +305,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -621,22 +314,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeletePipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeletePipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -644,10 +321,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -657,22 +330,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.DeleteTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseDeleteTrigger._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetChannel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -680,10 +337,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -693,22 +346,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetChannel._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetChannelConnection: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -716,10 +353,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -729,22 +362,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetChannelConnectionRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetChannelConnection._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -752,10 +369,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -765,22 +378,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -788,10 +385,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -801,22 +394,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetGoogleChannelConfig: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -824,10 +401,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -837,22 +410,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetGoogleChannelConfigRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetGoogleChannelConfig._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -860,10 +417,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -873,22 +426,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetPipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -896,10 +433,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -909,22 +442,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetPipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetPipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetProvider: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -932,10 +449,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -945,22 +458,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetProviderRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetProvider._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -968,10 +465,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -981,22 +474,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.GetTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseGetTrigger._get_unset_required_fields(query_params)) - - return query_params - class _BaseListChannelConnections: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1004,10 +481,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1017,22 +490,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListChannelConnectionsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListChannelConnections._get_unset_required_fields(query_params)) - - return query_params - class _BaseListChannels: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1040,10 +497,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1053,22 +506,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListChannelsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListChannels._get_unset_required_fields(query_params)) - - return query_params - class _BaseListEnrollments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1076,10 +513,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1089,22 +522,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListEnrollmentsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListEnrollments._get_unset_required_fields(query_params)) - - return query_params - class _BaseListGoogleApiSources: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1112,10 +529,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1125,22 +538,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListGoogleApiSourcesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListGoogleApiSources._get_unset_required_fields(query_params)) - - return query_params - class _BaseListMessageBusEnrollments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1148,10 +545,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1161,22 +554,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListMessageBusEnrollmentsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListMessageBusEnrollments._get_unset_required_fields(query_params)) - - return query_params - class _BaseListMessageBuses: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1184,10 +561,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1197,22 +570,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListMessageBusesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListMessageBuses._get_unset_required_fields(query_params)) - - return query_params - class _BaseListPipelines: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1220,10 +577,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1233,22 +586,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListPipelinesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListPipelines._get_unset_required_fields(query_params)) - - return query_params - class _BaseListProviders: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1256,10 +593,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1269,22 +602,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListProvidersRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListProviders._get_unset_required_fields(query_params)) - - return query_params - class _BaseListTriggers: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1292,10 +609,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1305,22 +618,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.ListTriggersRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseListTriggers._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateChannel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1335,30 +632,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateChannelRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - - return query_params - class _BaseUpdateEnrollment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1366,10 +639,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1380,31 +649,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateEnrollmentRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateEnrollment._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateGoogleApiSource: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1412,10 +656,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1426,31 +666,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateGoogleApiSourceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateGoogleApiSource._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateGoogleChannelConfig: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1458,10 +673,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1472,31 +683,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateGoogleChannelConfigRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateGoogleChannelConfig._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateMessageBus: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1504,10 +690,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1518,31 +700,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateMessageBusRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdateMessageBus._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdatePipeline: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1550,10 +707,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -1564,31 +717,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdatePipelineRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseEventarcRestTransport._BaseUpdatePipeline._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateTrigger: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1603,30 +731,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = eventarc.UpdateTriggerRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - - return query_params - class _BaseGetLocation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1640,18 +744,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1665,18 +757,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetIamPolicy: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1698,18 +778,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseSetIamPolicy: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1734,22 +802,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseTestIamPermissions: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1774,22 +826,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1804,22 +840,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1833,18 +853,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1858,18 +866,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1883,18 +879,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseEventarcRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_compat.py b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_compat.py index c6ba5691b2b3..85d4de185450 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.cloud.eventarc_v1._compat import transcode_request from google.cloud.eventarc_v1 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py index 277d0880e8cc..4672e81573e8 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py @@ -15529,16 +15529,18 @@ def test_get_trigger_rest_required_fields(request_type=eventarc.GetTriggerReques # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_trigger._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetTrigger, + "_BaseGetTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_trigger._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -15586,13 +15588,6 @@ def test_get_trigger_rest_required_fields(request_type=eventarc.GetTriggerReques assert sorted(expected_params) == sorted(actual_params) -def test_get_trigger_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_trigger._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_trigger_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -15695,17 +15690,20 @@ def test_list_triggers_rest_required_fields(request_type=eventarc.ListTriggersRe # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_triggers._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListTriggers, + "_BaseListTriggers__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_triggers._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -15754,13 +15752,6 @@ def test_list_triggers_rest_required_fields(request_type=eventarc.ListTriggersRe assert sorted(expected_params) == sorted(actual_params) -def test_list_triggers_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_triggers._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_triggers_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -15934,7 +15925,12 @@ def test_create_trigger_rest_required_fields(request_type=eventarc.CreateTrigger # verify fields with default values are dropped assert "triggerId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_trigger._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateTrigger, + "_BaseCreateTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -15944,10 +15940,8 @@ def test_create_trigger_rest_required_fields(request_type=eventarc.CreateTrigger jsonified_request["parent"] = 'parent_value' jsonified_request["triggerId"] = 'trigger_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_trigger._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("trigger_id", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("triggerId", "validateOnly", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -16000,13 +15994,6 @@ def test_create_trigger_rest_required_fields(request_type=eventarc.CreateTrigger assert sorted(expected_params) == sorted(actual_params) -def test_create_trigger_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_trigger._get_unset_required_fields({}) - assert set(unset_fields) == (set(("triggerId", "validateOnly", )) & set(("parent", "trigger", "triggerId", ))) - - def test_create_trigger_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16209,17 +16196,20 @@ def test_delete_trigger_rest_required_fields(request_type=eventarc.DeleteTrigger # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_trigger._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteTrigger, + "_BaseDeleteTrigger__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_trigger._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "etag", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "etag", "validateOnly", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -16265,13 +16255,6 @@ def test_delete_trigger_rest_required_fields(request_type=eventarc.DeleteTrigger assert sorted(expected_params) == sorted(actual_params) -def test_delete_trigger_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_trigger._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "etag", "validateOnly", )) & set(("name", ))) - - def test_delete_trigger_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16374,16 +16357,18 @@ def test_get_channel_rest_required_fields(request_type=eventarc.GetChannelReques # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_channel._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetChannel, + "_BaseGetChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_channel._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -16431,13 +16416,6 @@ def test_get_channel_rest_required_fields(request_type=eventarc.GetChannelReques assert sorted(expected_params) == sorted(actual_params) -def test_get_channel_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_channel._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_channel_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16540,17 +16518,20 @@ def test_list_channels_rest_required_fields(request_type=eventarc.ListChannelsRe # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_channels._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListChannels, + "_BaseListChannels__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_channels._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -16599,13 +16580,6 @@ def test_list_channels_rest_required_fields(request_type=eventarc.ListChannelsRe assert sorted(expected_params) == sorted(actual_params) -def test_list_channels_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_channels._get_unset_required_fields({}) - assert set(unset_fields) == (set(("orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_channels_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16779,7 +16753,12 @@ def test_create_channel_rest_required_fields(request_type=eventarc.CreateChannel # verify fields with default values are dropped assert "channelId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_channel_._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateChannel, + "_BaseCreateChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -16789,10 +16768,8 @@ def test_create_channel_rest_required_fields(request_type=eventarc.CreateChannel jsonified_request["parent"] = 'parent_value' jsonified_request["channelId"] = 'channel_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_channel_._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("channel_id", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("channelId", "validateOnly", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -16845,13 +16822,6 @@ def test_create_channel_rest_required_fields(request_type=eventarc.CreateChannel assert sorted(expected_params) == sorted(actual_params) -def test_create_channel_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_channel_._get_unset_required_fields({}) - assert set(unset_fields) == (set(("channelId", "validateOnly", )) & set(("parent", "channel", "channelId", ))) - - def test_create_channel_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17052,17 +17022,20 @@ def test_delete_channel_rest_required_fields(request_type=eventarc.DeleteChannel # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_channel._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteChannel, + "_BaseDeleteChannel__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_channel._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("validateOnly", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -17108,13 +17081,6 @@ def test_delete_channel_rest_required_fields(request_type=eventarc.DeleteChannel assert sorted(expected_params) == sorted(actual_params) -def test_delete_channel_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_channel._get_unset_required_fields({}) - assert set(unset_fields) == (set(("validateOnly", )) & set(("name", ))) - - def test_delete_channel_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17215,16 +17181,18 @@ def test_get_provider_rest_required_fields(request_type=eventarc.GetProviderRequ # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_provider._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetProvider, + "_BaseGetProvider__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_provider._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -17272,13 +17240,6 @@ def test_get_provider_rest_required_fields(request_type=eventarc.GetProviderRequ assert sorted(expected_params) == sorted(actual_params) -def test_get_provider_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_provider._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_provider_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17381,17 +17342,20 @@ def test_list_providers_rest_required_fields(request_type=eventarc.ListProviders # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_providers._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListProviders, + "_BaseListProviders__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_providers._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -17440,13 +17404,6 @@ def test_list_providers_rest_required_fields(request_type=eventarc.ListProviders assert sorted(expected_params) == sorted(actual_params) -def test_list_providers_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_providers._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_providers_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17614,16 +17571,18 @@ def test_get_channel_connection_rest_required_fields(request_type=eventarc.GetCh # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_channel_connection._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetChannelConnection, + "_BaseGetChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_channel_connection._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -17671,13 +17630,6 @@ def test_get_channel_connection_rest_required_fields(request_type=eventarc.GetCh assert sorted(expected_params) == sorted(actual_params) -def test_get_channel_connection_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_channel_connection._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_channel_connection_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17780,17 +17732,20 @@ def test_list_channel_connections_rest_required_fields(request_type=eventarc.Lis # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_channel_connections._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListChannelConnections, + "_BaseListChannelConnections__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_channel_connections._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -17839,13 +17794,6 @@ def test_list_channel_connections_rest_required_fields(request_type=eventarc.Lis assert sorted(expected_params) == sorted(actual_params) -def test_list_channel_connections_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_channel_connections._get_unset_required_fields({}) - assert set(unset_fields) == (set(("pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_channel_connections_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18019,7 +17967,12 @@ def test_create_channel_connection_rest_required_fields(request_type=eventarc.Cr # verify fields with default values are dropped assert "channelConnectionId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_channel_connection._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateChannelConnection, + "_BaseCreateChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -18029,10 +17982,8 @@ def test_create_channel_connection_rest_required_fields(request_type=eventarc.Cr jsonified_request["parent"] = 'parent_value' jsonified_request["channelConnectionId"] = 'channel_connection_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_channel_connection._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("channel_connection_id", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("channelConnectionId", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -18085,13 +18036,6 @@ def test_create_channel_connection_rest_required_fields(request_type=eventarc.Cr assert sorted(expected_params) == sorted(actual_params) -def test_create_channel_connection_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_channel_connection._get_unset_required_fields({}) - assert set(unset_fields) == (set(("channelConnectionId", )) & set(("parent", "channelConnection", "channelConnectionId", ))) - - def test_create_channel_connection_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18200,16 +18144,18 @@ def test_delete_channel_connection_rest_required_fields(request_type=eventarc.De # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_channel_connection._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteChannelConnection, + "_BaseDeleteChannelConnection__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_channel_connection._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -18254,13 +18200,6 @@ def test_delete_channel_connection_rest_required_fields(request_type=eventarc.De assert sorted(expected_params) == sorted(actual_params) -def test_delete_channel_connection_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_channel_connection._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_delete_channel_connection_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18361,16 +18300,18 @@ def test_get_google_channel_config_rest_required_fields(request_type=eventarc.Ge # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_google_channel_config._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetGoogleChannelConfig, + "_BaseGetGoogleChannelConfig__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_google_channel_config._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -18418,13 +18359,6 @@ def test_get_google_channel_config_rest_required_fields(request_type=eventarc.Ge assert sorted(expected_params) == sorted(actual_params) -def test_get_google_channel_config_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_google_channel_config._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_google_channel_config_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18526,15 +18460,18 @@ def test_update_google_channel_config_rest_required_fields(request_type=eventarc # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_google_channel_config._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateGoogleChannelConfig, + "_BaseUpdateGoogleChannelConfig__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_google_channel_config._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("updateMask", )) # verify required fields with non-default values are left alone @@ -18582,13 +18519,6 @@ def test_update_google_channel_config_rest_required_fields(request_type=eventarc assert sorted(expected_params) == sorted(actual_params) -def test_update_google_channel_config_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_google_channel_config._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask", )) & set(("googleChannelConfig", ))) - - def test_update_google_channel_config_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18693,16 +18623,18 @@ def test_get_message_bus_rest_required_fields(request_type=eventarc.GetMessageBu # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_message_bus._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetMessageBus, + "_BaseGetMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_message_bus._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -18750,13 +18682,6 @@ def test_get_message_bus_rest_required_fields(request_type=eventarc.GetMessageBu assert sorted(expected_params) == sorted(actual_params) -def test_get_message_bus_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_message_bus._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_message_bus_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18859,17 +18784,20 @@ def test_list_message_buses_rest_required_fields(request_type=eventarc.ListMessa # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_message_buses._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListMessageBuses, + "_BaseListMessageBuses__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_message_buses._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -18918,13 +18846,6 @@ def test_list_message_buses_rest_required_fields(request_type=eventarc.ListMessa assert sorted(expected_params) == sorted(actual_params) -def test_list_message_buses_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_message_buses._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_message_buses_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19092,17 +19013,20 @@ def test_list_message_bus_enrollments_rest_required_fields(request_type=eventarc # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_message_bus_enrollments._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListMessageBusEnrollments, + "_BaseListMessageBusEnrollments__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_message_bus_enrollments._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -19151,13 +19075,6 @@ def test_list_message_bus_enrollments_rest_required_fields(request_type=eventarc assert sorted(expected_params) == sorted(actual_params) -def test_list_message_bus_enrollments_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_message_bus_enrollments._get_unset_required_fields({}) - assert set(unset_fields) == (set(("pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_message_bus_enrollments_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19331,7 +19248,12 @@ def test_create_message_bus_rest_required_fields(request_type=eventarc.CreateMes # verify fields with default values are dropped assert "messageBusId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_message_bus._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateMessageBus, + "_BaseCreateMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -19341,10 +19263,8 @@ def test_create_message_bus_rest_required_fields(request_type=eventarc.CreateMes jsonified_request["parent"] = 'parent_value' jsonified_request["messageBusId"] = 'message_bus_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_message_bus._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("message_bus_id", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("messageBusId", "validateOnly", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -19397,13 +19317,6 @@ def test_create_message_bus_rest_required_fields(request_type=eventarc.CreateMes assert sorted(expected_params) == sorted(actual_params) -def test_create_message_bus_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_message_bus._get_unset_required_fields({}) - assert set(unset_fields) == (set(("messageBusId", "validateOnly", )) & set(("parent", "messageBus", "messageBusId", ))) - - def test_create_message_bus_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19511,15 +19424,18 @@ def test_update_message_bus_rest_required_fields(request_type=eventarc.UpdateMes # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_message_bus._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateMessageBus, + "_BaseUpdateMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_message_bus._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "update_mask", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "updateMask", "validateOnly", )) # verify required fields with non-default values are left alone @@ -19564,13 +19480,6 @@ def test_update_message_bus_rest_required_fields(request_type=eventarc.UpdateMes assert sorted(expected_params) == sorted(actual_params) -def test_update_message_bus_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_message_bus._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "updateMask", "validateOnly", )) & set(("messageBus", ))) - - def test_update_message_bus_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19677,17 +19586,20 @@ def test_delete_message_bus_rest_required_fields(request_type=eventarc.DeleteMes # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_message_bus._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteMessageBus, + "_BaseDeleteMessageBus__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_message_bus._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "etag", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "etag", "validateOnly", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -19733,13 +19645,6 @@ def test_delete_message_bus_rest_required_fields(request_type=eventarc.DeleteMes assert sorted(expected_params) == sorted(actual_params) -def test_delete_message_bus_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_message_bus._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "etag", "validateOnly", )) & set(("name", ))) - - def test_delete_message_bus_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19842,16 +19747,18 @@ def test_get_enrollment_rest_required_fields(request_type=eventarc.GetEnrollment # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_enrollment._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetEnrollment, + "_BaseGetEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_enrollment._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -19899,13 +19806,6 @@ def test_get_enrollment_rest_required_fields(request_type=eventarc.GetEnrollment assert sorted(expected_params) == sorted(actual_params) -def test_get_enrollment_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_enrollment._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_enrollment_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20008,17 +19908,20 @@ def test_list_enrollments_rest_required_fields(request_type=eventarc.ListEnrollm # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_enrollments._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListEnrollments, + "_BaseListEnrollments__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_enrollments._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -20067,13 +19970,6 @@ def test_list_enrollments_rest_required_fields(request_type=eventarc.ListEnrollm assert sorted(expected_params) == sorted(actual_params) -def test_list_enrollments_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_enrollments._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_enrollments_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20247,7 +20143,12 @@ def test_create_enrollment_rest_required_fields(request_type=eventarc.CreateEnro # verify fields with default values are dropped assert "enrollmentId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_enrollment._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateEnrollment, + "_BaseCreateEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -20257,10 +20158,8 @@ def test_create_enrollment_rest_required_fields(request_type=eventarc.CreateEnro jsonified_request["parent"] = 'parent_value' jsonified_request["enrollmentId"] = 'enrollment_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_enrollment._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("enrollment_id", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("enrollmentId", "validateOnly", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -20313,13 +20212,6 @@ def test_create_enrollment_rest_required_fields(request_type=eventarc.CreateEnro assert sorted(expected_params) == sorted(actual_params) -def test_create_enrollment_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_enrollment._get_unset_required_fields({}) - assert set(unset_fields) == (set(("enrollmentId", "validateOnly", )) & set(("parent", "enrollment", "enrollmentId", ))) - - def test_create_enrollment_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20427,15 +20319,18 @@ def test_update_enrollment_rest_required_fields(request_type=eventarc.UpdateEnro # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_enrollment._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateEnrollment, + "_BaseUpdateEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_enrollment._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "update_mask", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "updateMask", "validateOnly", )) # verify required fields with non-default values are left alone @@ -20480,13 +20375,6 @@ def test_update_enrollment_rest_required_fields(request_type=eventarc.UpdateEnro assert sorted(expected_params) == sorted(actual_params) -def test_update_enrollment_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_enrollment._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "updateMask", "validateOnly", )) & set(("enrollment", ))) - - def test_update_enrollment_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20593,17 +20481,20 @@ def test_delete_enrollment_rest_required_fields(request_type=eventarc.DeleteEnro # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_enrollment._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteEnrollment, + "_BaseDeleteEnrollment__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_enrollment._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "etag", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "etag", "validateOnly", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -20649,13 +20540,6 @@ def test_delete_enrollment_rest_required_fields(request_type=eventarc.DeleteEnro assert sorted(expected_params) == sorted(actual_params) -def test_delete_enrollment_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_enrollment._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "etag", "validateOnly", )) & set(("name", ))) - - def test_delete_enrollment_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20758,16 +20642,18 @@ def test_get_pipeline_rest_required_fields(request_type=eventarc.GetPipelineRequ # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_pipeline._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetPipeline, + "_BaseGetPipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_pipeline._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -20815,13 +20701,6 @@ def test_get_pipeline_rest_required_fields(request_type=eventarc.GetPipelineRequ assert sorted(expected_params) == sorted(actual_params) -def test_get_pipeline_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_pipeline._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_pipeline_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20924,17 +20803,20 @@ def test_list_pipelines_rest_required_fields(request_type=eventarc.ListPipelines # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_pipelines._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListPipelines, + "_BaseListPipelines__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_pipelines._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -20983,13 +20865,6 @@ def test_list_pipelines_rest_required_fields(request_type=eventarc.ListPipelines assert sorted(expected_params) == sorted(actual_params) -def test_list_pipelines_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_pipelines._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_pipelines_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -21163,7 +21038,12 @@ def test_create_pipeline_rest_required_fields(request_type=eventarc.CreatePipeli # verify fields with default values are dropped assert "pipelineId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_pipeline._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreatePipeline, + "_BaseCreatePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -21173,10 +21053,8 @@ def test_create_pipeline_rest_required_fields(request_type=eventarc.CreatePipeli jsonified_request["parent"] = 'parent_value' jsonified_request["pipelineId"] = 'pipeline_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_pipeline._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("pipeline_id", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("pipelineId", "validateOnly", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -21229,13 +21107,6 @@ def test_create_pipeline_rest_required_fields(request_type=eventarc.CreatePipeli assert sorted(expected_params) == sorted(actual_params) -def test_create_pipeline_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_pipeline._get_unset_required_fields({}) - assert set(unset_fields) == (set(("pipelineId", "validateOnly", )) & set(("parent", "pipeline", "pipelineId", ))) - - def test_create_pipeline_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -21343,15 +21214,18 @@ def test_update_pipeline_rest_required_fields(request_type=eventarc.UpdatePipeli # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_pipeline._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdatePipeline, + "_BaseUpdatePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_pipeline._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "update_mask", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "updateMask", "validateOnly", )) # verify required fields with non-default values are left alone @@ -21396,13 +21270,6 @@ def test_update_pipeline_rest_required_fields(request_type=eventarc.UpdatePipeli assert sorted(expected_params) == sorted(actual_params) -def test_update_pipeline_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_pipeline._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "updateMask", "validateOnly", )) & set(("pipeline", ))) - - def test_update_pipeline_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -21509,17 +21376,20 @@ def test_delete_pipeline_rest_required_fields(request_type=eventarc.DeletePipeli # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_pipeline._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeletePipeline, + "_BaseDeletePipeline__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_pipeline._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "etag", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "etag", "validateOnly", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -21565,13 +21435,6 @@ def test_delete_pipeline_rest_required_fields(request_type=eventarc.DeletePipeli assert sorted(expected_params) == sorted(actual_params) -def test_delete_pipeline_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_pipeline._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "etag", "validateOnly", )) & set(("name", ))) - - def test_delete_pipeline_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -21674,16 +21537,18 @@ def test_get_google_api_source_rest_required_fields(request_type=eventarc.GetGoo # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_google_api_source._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetGoogleApiSource, + "_BaseGetGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_google_api_source._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -21731,13 +21596,6 @@ def test_get_google_api_source_rest_required_fields(request_type=eventarc.GetGoo assert sorted(expected_params) == sorted(actual_params) -def test_get_google_api_source_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_google_api_source._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_google_api_source_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -21840,17 +21698,20 @@ def test_list_google_api_sources_rest_required_fields(request_type=eventarc.List # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_google_api_sources._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListGoogleApiSources, + "_BaseListGoogleApiSources__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_google_api_sources._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -21899,13 +21760,6 @@ def test_list_google_api_sources_rest_required_fields(request_type=eventarc.List assert sorted(expected_params) == sorted(actual_params) -def test_list_google_api_sources_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_google_api_sources._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_google_api_sources_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -22079,7 +21933,12 @@ def test_create_google_api_source_rest_required_fields(request_type=eventarc.Cre # verify fields with default values are dropped assert "googleApiSourceId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_google_api_source._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateGoogleApiSource, + "_BaseCreateGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -22089,10 +21948,8 @@ def test_create_google_api_source_rest_required_fields(request_type=eventarc.Cre jsonified_request["parent"] = 'parent_value' jsonified_request["googleApiSourceId"] = 'google_api_source_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_google_api_source._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("google_api_source_id", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("googleApiSourceId", "validateOnly", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -22145,13 +22002,6 @@ def test_create_google_api_source_rest_required_fields(request_type=eventarc.Cre assert sorted(expected_params) == sorted(actual_params) -def test_create_google_api_source_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_google_api_source._get_unset_required_fields({}) - assert set(unset_fields) == (set(("googleApiSourceId", "validateOnly", )) & set(("parent", "googleApiSource", "googleApiSourceId", ))) - - def test_create_google_api_source_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -22259,15 +22109,18 @@ def test_update_google_api_source_rest_required_fields(request_type=eventarc.Upd # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_google_api_source._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateGoogleApiSource, + "_BaseUpdateGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_google_api_source._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "update_mask", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "updateMask", "validateOnly", )) # verify required fields with non-default values are left alone @@ -22312,13 +22165,6 @@ def test_update_google_api_source_rest_required_fields(request_type=eventarc.Upd assert sorted(expected_params) == sorted(actual_params) -def test_update_google_api_source_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_google_api_source._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "updateMask", "validateOnly", )) & set(("googleApiSource", ))) - - def test_update_google_api_source_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), @@ -22425,17 +22271,20 @@ def test_delete_google_api_source_rest_required_fields(request_type=eventarc.Del # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_google_api_source._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteGoogleApiSource, + "_BaseDeleteGoogleApiSource__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_google_api_source._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("allow_missing", "etag", "validate_only", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("allowMissing", "etag", "validateOnly", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -22481,13 +22330,6 @@ def test_delete_google_api_source_rest_required_fields(request_type=eventarc.Del assert sorted(expected_params) == sorted(actual_params) -def test_delete_google_api_source_rest_unset_required_fields(): - transport = transports.EventarcRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_google_api_source._get_unset_required_fields({}) - assert set(unset_fields) == (set(("allowMissing", "etag", "validateOnly", )) & set(("name", ))) - - def test_delete_google_api_source_rest_flattened(): client = EventarcClient( credentials=ga_credentials.AnonymousCredentials(), diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_compat.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_compat.py index 4d2f8c2a01b2..163c0fc6a37e 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.cloud.logging_v2._compat import transcode_request from google.cloud.logging_v2 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_compat.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_compat.py index 4d2f8c2a01b2..163c0fc6a37e 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.cloud.logging_v2._compat import transcode_request from google.cloud.logging_v2 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 013062f304b2..ea8778e47a84 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +from google.cloud.redis_v1._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -944,14 +945,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1067,12 +1071,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1189,14 +1198,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseExportInstance._get_http_options() - request, metadata = self._interceptor.pre_export_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseExportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseExportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseExportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseExportInstance, + "_BaseExportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1313,14 +1325,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_http_options() - request, metadata = self._interceptor.pre_failover_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseFailoverInstance, + "_BaseFailoverInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1433,12 +1448,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1553,12 +1573,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_http_options() - request, metadata = self._interceptor.pre_get_instance_auth_string(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstanceAuthString, + "_BaseGetInstanceAuthString__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1677,14 +1702,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseImportInstance._get_http_options() - request, metadata = self._interceptor.pre_import_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseImportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseImportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseImportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseImportInstance, + "_BaseImportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1799,12 +1827,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1923,14 +1956,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_http_options() - request, metadata = self._interceptor.pre_reschedule_maintenance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseRescheduleMaintenance, + "_BaseRescheduleMaintenance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2047,14 +2083,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2171,14 +2210,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_http_options() - request, metadata = self._interceptor.pre_upgrade_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpgradeInstance, + "_BaseUpgradeInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2382,12 +2424,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2500,12 +2547,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2615,12 +2667,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2707,12 +2764,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2802,12 +2864,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2920,12 +2987,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3039,14 +3111,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index d827de47ee24..4d629a5a8443 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -32,6 +32,8 @@ from google.api_core import retry_async as retries from google.api_core import rest_helpers from google.api_core import rest_streaming_async # type: ignore +from google.cloud.redis_v1._compat import transcode_request + import google.protobuf from google.protobuf import json_format @@ -969,14 +971,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = await self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1098,12 +1103,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = await self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1226,14 +1236,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseExportInstance._get_http_options() - request, metadata = await self._interceptor.pre_export_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseExportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseExportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseExportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseExportInstance, + "_BaseExportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1356,14 +1369,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_http_options() - request, metadata = await self._interceptor.pre_failover_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseFailoverInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseFailoverInstance, + "_BaseFailoverInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1482,12 +1498,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = await self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1606,12 +1627,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_http_options() - request, metadata = await self._interceptor.pre_get_instance_auth_string(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstanceAuthString, + "_BaseGetInstanceAuthString__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1734,14 +1760,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseImportInstance._get_http_options() - request, metadata = await self._interceptor.pre_import_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseImportInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseImportInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseImportInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseImportInstance, + "_BaseImportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1862,12 +1891,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = await self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1990,14 +2024,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_http_options() - request, metadata = await self._interceptor.pre_reschedule_maintenance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseRescheduleMaintenance, + "_BaseRescheduleMaintenance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2120,14 +2157,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = await self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2250,14 +2290,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_http_options() - request, metadata = await self._interceptor.pre_upgrade_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpgradeInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpgradeInstance, + "_BaseUpgradeInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2501,12 +2544,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = await self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2623,12 +2671,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = await self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2742,12 +2795,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = await self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2838,12 +2896,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = await self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2937,12 +3000,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = await self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3059,12 +3127,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = await self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -3182,14 +3255,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = await self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py index 65352deb5bbf..972b14a1295e 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py @@ -94,10 +94,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "instanceId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -108,31 +104,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.CreateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseCreateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -140,10 +111,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -153,22 +120,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.DeleteInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseDeleteInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseExportInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -176,10 +127,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -190,31 +137,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ExportInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseExportInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseFailoverInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -222,10 +144,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -236,31 +154,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.FailoverInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseFailoverInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -268,10 +161,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -281,22 +170,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.GetInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseGetInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetInstanceAuthString: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -304,10 +177,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -317,22 +186,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.GetInstanceAuthStringRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseGetInstanceAuthString._get_unset_required_fields(query_params)) - - return query_params - class _BaseImportInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -340,10 +193,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -354,31 +203,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ImportInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseImportInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseListInstances: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -386,10 +210,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -399,22 +219,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ListInstancesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseListInstances._get_unset_required_fields(query_params)) - - return query_params - class _BaseRescheduleMaintenance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -422,10 +226,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -436,31 +236,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.RescheduleMaintenanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseRescheduleMaintenance._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -468,10 +243,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "updateMask" : {}, } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -482,31 +253,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.UpdateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseUpdateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpgradeInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -514,10 +260,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -528,31 +270,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.UpgradeInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseUpgradeInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetLocation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -566,18 +283,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -591,18 +296,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -616,18 +309,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -641,18 +322,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -666,18 +335,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -691,18 +348,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseWaitOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -717,22 +362,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseCloudRedisRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py index 89a2ea389ad4..16a578140292 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py @@ -4857,17 +4857,20 @@ def test_list_instances_rest_required_fields(request_type=cloud_redis.ListInstan # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_instances._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_instances._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -4916,13 +4919,6 @@ def test_list_instances_rest_required_fields(request_type=cloud_redis.ListInstan assert sorted(expected_params) == sorted(actual_params) -def test_list_instances_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_instances._get_unset_required_fields({}) - assert set(unset_fields) == (set(("pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_instances_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5090,16 +5086,18 @@ def test_get_instance_rest_required_fields(request_type=cloud_redis.GetInstanceR # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -5147,13 +5145,6 @@ def test_get_instance_rest_required_fields(request_type=cloud_redis.GetInstanceR assert sorted(expected_params) == sorted(actual_params) -def test_get_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5256,16 +5247,18 @@ def test_get_instance_auth_string_rest_required_fields(request_type=cloud_redis. # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_instance_auth_string._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetInstanceAuthString, + "_BaseGetInstanceAuthString__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_instance_auth_string._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -5313,13 +5306,6 @@ def test_get_instance_auth_string_rest_required_fields(request_type=cloud_redis. assert sorted(expected_params) == sorted(actual_params) -def test_get_instance_auth_string_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_instance_auth_string._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_instance_auth_string_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5428,7 +5414,12 @@ def test_create_instance_rest_required_fields(request_type=cloud_redis.CreateIns # verify fields with default values are dropped assert "instanceId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -5438,10 +5429,8 @@ def test_create_instance_rest_required_fields(request_type=cloud_redis.CreateIns jsonified_request["parent"] = 'parent_value' jsonified_request["instanceId"] = 'instance_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_instance._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("instance_id", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("instanceId", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -5494,13 +5483,6 @@ def test_create_instance_rest_required_fields(request_type=cloud_redis.CreateIns assert sorted(expected_params) == sorted(actual_params) -def test_create_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(("instanceId", )) & set(("parent", "instanceId", "instance", ))) - - def test_create_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5608,15 +5590,18 @@ def test_update_instance_rest_required_fields(request_type=cloud_redis.UpdateIns # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_instance._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("updateMask", )) # verify required fields with non-default values are left alone @@ -5661,13 +5646,6 @@ def test_update_instance_rest_required_fields(request_type=cloud_redis.UpdateIns assert sorted(expected_params) == sorted(actual_params) -def test_update_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask", )) & set(("updateMask", "instance", ))) - - def test_update_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5775,7 +5753,12 @@ def test_upgrade_instance_rest_required_fields(request_type=cloud_redis.UpgradeI # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).upgrade_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpgradeInstance, + "_BaseUpgradeInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -5783,9 +5766,6 @@ def test_upgrade_instance_rest_required_fields(request_type=cloud_redis.UpgradeI jsonified_request["name"] = 'name_value' jsonified_request["redisVersion"] = 'redis_version_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).upgrade_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -5833,13 +5813,6 @@ def test_upgrade_instance_rest_required_fields(request_type=cloud_redis.UpgradeI assert sorted(expected_params) == sorted(actual_params) -def test_upgrade_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.upgrade_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "redisVersion", ))) - - def test_upgrade_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5946,16 +5919,18 @@ def test_import_instance_rest_required_fields(request_type=cloud_redis.ImportIns # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).import_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseImportInstance, + "_BaseImportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).import_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -6001,13 +5976,6 @@ def test_import_instance_rest_required_fields(request_type=cloud_redis.ImportIns assert sorted(expected_params) == sorted(actual_params) -def test_import_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.import_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "inputConfig", ))) - - def test_import_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6114,16 +6082,18 @@ def test_export_instance_rest_required_fields(request_type=cloud_redis.ExportIns # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).export_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseExportInstance, + "_BaseExportInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).export_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -6169,13 +6139,6 @@ def test_export_instance_rest_required_fields(request_type=cloud_redis.ExportIns assert sorted(expected_params) == sorted(actual_params) -def test_export_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.export_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "outputConfig", ))) - - def test_export_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6282,16 +6245,18 @@ def test_failover_instance_rest_required_fields(request_type=cloud_redis.Failove # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).failover_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseFailoverInstance, + "_BaseFailoverInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).failover_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -6337,13 +6302,6 @@ def test_failover_instance_rest_required_fields(request_type=cloud_redis.Failove assert sorted(expected_params) == sorted(actual_params) -def test_failover_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.failover_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_failover_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6450,16 +6408,18 @@ def test_delete_instance_rest_required_fields(request_type=cloud_redis.DeleteIns # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -6504,13 +6464,6 @@ def test_delete_instance_rest_required_fields(request_type=cloud_redis.DeleteIns assert sorted(expected_params) == sorted(actual_params) -def test_delete_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_delete_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6615,16 +6568,18 @@ def test_reschedule_maintenance_rest_required_fields(request_type=cloud_redis.Re # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).reschedule_maintenance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseRescheduleMaintenance, + "_BaseRescheduleMaintenance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).reschedule_maintenance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -6670,13 +6625,6 @@ def test_reschedule_maintenance_rest_required_fields(request_type=cloud_redis.Re assert sorted(expected_params) == sorted(actual_params) -def test_reschedule_maintenance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.reschedule_maintenance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", "rescheduleType", ))) - - def test_reschedule_maintenance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), diff --git a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_compat.py b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_compat.py index 5caa250d85a1..2328e5d1ab15 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.cloud.redis_v1._compat import transcode_request from google.cloud.redis_v1 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py index cb118c8f3409..055bfe3326d0 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/_compat.py @@ -15,7 +15,12 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json + +from typing import Any, Dict, List, Optional, Tuple + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError @@ -138,3 +143,61 @@ def get_universe_domain( if not resolved: raise EmptyUniverseError() return resolved + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 230965c05d9c..2f972ef00317 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +from google.cloud.redis_v1._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -680,14 +681,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -803,12 +807,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -921,12 +930,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1043,12 +1057,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1167,14 +1186,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1330,12 +1352,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1448,12 +1475,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1563,12 +1595,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1655,12 +1692,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1750,12 +1792,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1868,12 +1915,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1987,14 +2039,17 @@ def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index bcd5f851f97f..960d9639a214 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -32,6 +32,8 @@ from google.api_core import retry_async as retries from google.api_core import rest_helpers from google.api_core import rest_streaming_async # type: ignore +from google.cloud.redis_v1._compat import transcode_request + import google.protobuf from google.protobuf import json_format @@ -675,14 +677,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCreateInstance._get_http_options() - request, metadata = await self._interceptor.pre_create_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCreateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseCreateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCreateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -804,12 +809,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_http_options() - request, metadata = await self._interceptor.pre_delete_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -928,12 +938,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetInstance._get_http_options() - request, metadata = await self._interceptor.pre_get_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetInstance._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1054,12 +1069,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListInstances._get_http_options() - request, metadata = await self._interceptor.pre_list_instances(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListInstances._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListInstances._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1182,14 +1202,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_http_options() - request, metadata = await self._interceptor.pre_update_instance(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseUpdateInstance._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1397,12 +1420,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetLocation._get_http_options() - request, metadata = await self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1519,12 +1547,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListLocations._get_http_options() - request, metadata = await self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1638,12 +1671,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseCancelOperation._get_http_options() - request, metadata = await self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1734,12 +1772,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = await self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1833,12 +1876,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseGetOperation._get_http_options() - request, metadata = await self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1955,12 +2003,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseListOperations._get_http_options() - request, metadata = await self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2078,14 +2131,17 @@ async def __call__(self, """ http_options = _BaseCloudRedisRestTransport._BaseWaitOperation._get_http_options() - request, metadata = await self._interceptor.pre_wait_operation(request, metadata) - transcoded_request = _BaseCloudRedisRestTransport._BaseWaitOperation._get_transcoded_request(http_options, request) - - body = _BaseCloudRedisRestTransport._BaseWaitOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseCloudRedisRestTransport._BaseWaitOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseCloudRedisRestTransport._BaseWaitOperation, + "_BaseWaitOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py index ff18d15f1290..7e9b4428533c 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_base.py @@ -94,10 +94,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "instanceId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -108,31 +104,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.CreateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseCreateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -140,10 +111,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -153,22 +120,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.DeleteInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseDeleteInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -176,10 +127,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -189,22 +136,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.GetInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseGetInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseListInstances: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -212,10 +143,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -225,22 +152,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.ListInstancesRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseListInstances._get_unset_required_fields(query_params)) - - return query_params - class _BaseUpdateInstance: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -248,10 +159,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "updateMask" : {}, } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -262,31 +169,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = cloud_redis.UpdateInstanceRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseCloudRedisRestTransport._BaseUpdateInstance._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetLocation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -300,18 +182,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -325,18 +195,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -350,18 +208,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -375,18 +221,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -400,18 +234,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -425,18 +247,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseWaitOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -451,22 +261,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseCloudRedisRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py index 94a7b49589be..2ae0bcd38c80 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py @@ -2905,17 +2905,20 @@ def test_list_instances_rest_required_fields(request_type=cloud_redis.ListInstan # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_instances._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListInstances, + "_BaseListInstances__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_instances._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -2964,13 +2967,6 @@ def test_list_instances_rest_required_fields(request_type=cloud_redis.ListInstan assert sorted(expected_params) == sorted(actual_params) -def test_list_instances_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_instances._get_unset_required_fields({}) - assert set(unset_fields) == (set(("pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_instances_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3138,16 +3134,18 @@ def test_get_instance_rest_required_fields(request_type=cloud_redis.GetInstanceR # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetInstance, + "_BaseGetInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -3195,13 +3193,6 @@ def test_get_instance_rest_required_fields(request_type=cloud_redis.GetInstanceR assert sorted(expected_params) == sorted(actual_params) -def test_get_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3310,7 +3301,12 @@ def test_create_instance_rest_required_fields(request_type=cloud_redis.CreateIns # verify fields with default values are dropped assert "instanceId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateInstance, + "_BaseCreateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -3320,10 +3316,8 @@ def test_create_instance_rest_required_fields(request_type=cloud_redis.CreateIns jsonified_request["parent"] = 'parent_value' jsonified_request["instanceId"] = 'instance_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_instance._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("instance_id", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("instanceId", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -3376,13 +3370,6 @@ def test_create_instance_rest_required_fields(request_type=cloud_redis.CreateIns assert sorted(expected_params) == sorted(actual_params) -def test_create_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(("instanceId", )) & set(("parent", "instanceId", "instance", ))) - - def test_create_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3490,15 +3477,18 @@ def test_update_instance_rest_required_fields(request_type=cloud_redis.UpdateIns # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseUpdateInstance, + "_BaseUpdateInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).update_instance._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("updateMask", )) # verify required fields with non-default values are left alone @@ -3543,13 +3533,6 @@ def test_update_instance_rest_required_fields(request_type=cloud_redis.UpdateIns assert sorted(expected_params) == sorted(actual_params) -def test_update_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.update_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask", )) & set(("updateMask", "instance", ))) - - def test_update_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3656,16 +3639,18 @@ def test_delete_instance_rest_required_fields(request_type=cloud_redis.DeleteIns # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_instance._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteInstance, + "_BaseDeleteInstance__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_instance._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -3710,13 +3695,6 @@ def test_delete_instance_rest_required_fields(request_type=cloud_redis.DeleteIns assert sorted(expected_params) == sorted(actual_params) -def test_delete_instance_rest_unset_required_fields(): - transport = transports.CloudRedisRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_instance._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_delete_instance_rest_flattened(): client = CloudRedisClient( credentials=ga_credentials.AnonymousCredentials(), diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_compat.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_compat.py index 5caa250d85a1..2328e5d1ab15 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_compat.py @@ -15,9 +15,14 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +from unittest import mock + +from google.protobuf import descriptor_pb2 + +from google.cloud.redis_v1._compat import transcode_request from google.cloud.redis_v1 import _compat as universe from google.auth.exceptions import MutualTLSChannelError @@ -217,3 +222,176 @@ def test_get_api_endpoint( ) == expected ) + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py index c951a8a71847..f20bbdc55a5b 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/_compat.py @@ -15,14 +15,19 @@ # """A compatibility module for older versions of google-api-core.""" -from typing import Optional +import json +import uuid + +from typing import Any, Dict, List, Optional, Tuple +from typing import Union + +from google.api_core import path_template +from google.protobuf import json_format from urllib.parse import urlparse, urlunparse from google.auth.exceptions import MutualTLSChannelError from google.api_core.universe import EmptyUniverseError -import uuid -from typing import Union import google.protobuf.message DEFAULT_UNIVERSE = "googleapis.com" @@ -186,3 +191,61 @@ def setup_request_id( else: if not getattr(request, field_name, None): setattr(request, field_name, str(uuid.uuid4())) + + +def transcode_request( + http_options: List[Dict[str, str]], + request: Any, + required_fields_default_values: Optional[Dict[str, Any]] = None, + rest_numeric_enums: bool = False, +) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: + """Transcodes a request into HTTP method, URI, body, and query parameters. + + Args: + http_options (List[Dict[str, str]]): List of HTTP transcoding rules. + request (Any): The protobuf or proto-plus request message. + required_fields_default_values (Optional[Dict[str, Any]]): Dictionary + of required fields default values to merge into query parameters if missing. + rest_numeric_enums (bool): Whether to encode enums as integers. + + Returns: + Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing: + - The raw transcoded request dictionary (containing keys like 'uri', 'method'). + - The serialized request body JSON string, or None if no body. + - The query parameters dictionary. + """ + if request is None: + raise TypeError("request cannot be None") + + # Convert proto-plus message to its underlying protobuf message if needed + pb_request = getattr(request, "_pb", request) + + transcoded_request = path_template.transcode(http_options, pb_request) + + body_json = None + if transcoded_request.get("body") is not None: + body_json = json_format.MessageToJson( + transcoded_request["body"], + use_integers_for_enums=rest_numeric_enums, + ) + + query_params_json = {} + if transcoded_request.get("query_params") is not None: + query_params_json = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=rest_numeric_enums, + ) + ) + + # If required_fields_default_values is provided, we merge default values for missing + # required fields into the query parameters. + if required_fields_default_values: + for k, v in required_fields_default_values.items(): + if k not in query_params_json: + query_params_json[k] = v + + if rest_numeric_enums: + query_params_json["$alt"] = "json;enum-encoding=int" + + return transcoded_request, body_json, query_params_json diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py index 06ea5eab316d..9a4373457926 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +from google.cloud.storagebatchoperations_v1._compat import transcode_request import google.protobuf from google.protobuf import json_format @@ -691,14 +692,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_http_options() - request, metadata = self._interceptor.pre_cancel_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_transcoded_request(http_options, request) - - body = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseCancelJob, + "_BaseCancelJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -816,14 +820,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_http_options() - request, metadata = self._interceptor.pre_create_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_transcoded_request(http_options, request) - - body = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseCreateJob, + "_BaseCreateJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -931,12 +938,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_http_options() - request, metadata = self._interceptor.pre_delete_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseDeleteJob, + "_BaseDeleteJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1023,12 +1035,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_http_options() - request, metadata = self._interceptor.pre_get_bucket_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation, + "_BaseGetBucketOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1144,12 +1161,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetJob._get_http_options() - request, metadata = self._interceptor.pre_get_job(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetJob._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetJob._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetJob, + "_BaseGetJob__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1266,12 +1288,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_http_options() - request, metadata = self._interceptor.pre_list_bucket_operations(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListBucketOperations, + "_BaseListBucketOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1385,12 +1412,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListJobs._get_http_options() - request, metadata = self._interceptor.pre_list_jobs(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListJobs._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListJobs._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListJobs, + "_BaseListJobs__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1564,12 +1596,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetLocation._get_http_options() - request, metadata = self._interceptor.pre_get_location(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetLocation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetLocation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetLocation, + "_BaseGetLocation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1682,12 +1719,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListLocations._get_http_options() - request, metadata = self._interceptor.pre_list_locations(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListLocations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListLocations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListLocations, + "_BaseListLocations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1798,14 +1840,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_http_options() - request, metadata = self._interceptor.pre_cancel_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_transcoded_request(http_options, request) - - body = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_request_body_json(transcoded_request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseCancelOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseCancelOperation, + "_BaseCancelOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1892,12 +1937,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation._get_http_options() - request, metadata = self._interceptor.pre_delete_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseDeleteOperation, + "_BaseDeleteOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -1987,12 +2037,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseGetOperation._get_http_options() - request, metadata = self._interceptor.pre_get_operation(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseGetOperation._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseGetOperation._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseGetOperation, + "_BaseGetOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) @@ -2105,12 +2160,17 @@ def __call__(self, """ http_options = _BaseStorageBatchOperationsRestTransport._BaseListOperations._get_http_options() - request, metadata = self._interceptor.pre_list_operations(request, metadata) - transcoded_request = _BaseStorageBatchOperationsRestTransport._BaseListOperations._get_transcoded_request(http_options, request) - - # Jsonify the query params - query_params = _BaseStorageBatchOperationsRestTransport._BaseListOperations._get_query_params_json(transcoded_request) + transcoded_request, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=getattr( + _BaseStorageBatchOperationsRestTransport._BaseListOperations, + "_BaseListOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + None, + ), + rest_numeric_enums=False, + ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py index 280692aac74f..3066715fa681 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest_base.py @@ -96,10 +96,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -110,31 +106,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.CancelJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseCancelJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseCreateJob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -142,10 +113,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { "jobId" : "", } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -156,31 +123,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.CreateJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - # Jsonify the request body - - body = json_format.MessageToJson( - transcoded_request['body'], - use_integers_for_enums=False - ) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseCreateJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseDeleteJob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -188,10 +130,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -201,22 +139,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.DeleteJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseDeleteJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetBucketOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -224,10 +146,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -237,22 +155,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.GetBucketOperationRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseGetBucketOperation._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetJob: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -260,10 +162,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -273,22 +171,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.GetJobRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseGetJob._get_unset_required_fields(query_params)) - - return query_params - class _BaseListBucketOperations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -296,10 +178,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -309,22 +187,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.ListBucketOperationsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseListBucketOperations._get_unset_required_fields(query_params)) - - return query_params - class _BaseListJobs: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -332,10 +194,6 @@ def __hash__(self): # pragma: NO COVER __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { } - @classmethod - def _get_unset_required_fields(cls, message_dict): - return {k: v for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() if k not in message_dict} - @staticmethod def _get_http_options(): http_options: List[Dict[str, str]] = [{ @@ -345,22 +203,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - pb_request = storage_batch_operations.ListJobsRequest.pb(request) - transcoded_request = path_template.transcode(http_options, pb_request) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json_format.MessageToJson( - transcoded_request['query_params'], - use_integers_for_enums=False, - )) - query_params.update(_BaseStorageBatchOperationsRestTransport._BaseListJobs._get_unset_required_fields(query_params)) - - return query_params - class _BaseGetLocation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -374,18 +216,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListLocations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -399,18 +229,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseCancelOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -425,22 +243,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_request_body_json(transcoded_request): - body = json.dumps(transcoded_request['body']) - return body - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseDeleteOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -454,18 +256,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseGetOperation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -479,18 +269,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - class _BaseListOperations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -504,18 +282,6 @@ def _get_http_options(): ] return http_options - @staticmethod - def _get_transcoded_request(http_options, request): - request_kwargs = json_format.MessageToDict(request) - transcoded_request = path_template.transcode( - http_options, **request_kwargs) - return transcoded_request - - @staticmethod - def _get_query_params_json(transcoded_request): - query_params = json.loads(json.dumps(transcoded_request['query_params'])) - return query_params - __all__=( '_BaseStorageBatchOperationsRestTransport', diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_compat.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_compat.py index 52b112caef3f..caee9d17acbf 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_compat.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_compat.py @@ -15,9 +15,15 @@ # """Tests for the compatibility module for older versions of google-api-core.""" -import re +import json import pytest +import re + +from unittest import mock + +from google.protobuf import descriptor_pb2 +from google.cloud.storagebatchoperations_v1._compat import transcode_request from google.cloud.storagebatchoperations_v1 import _compat as universe from google.cloud.storagebatchoperations_v1._compat import setup_request_id @@ -299,3 +305,176 @@ def test_setup_request_id(request_obj, is_proto3_optional, expected): assert re.match(UUID_REGEX, value) else: assert value == expected + + +def test_transcode_basic(): + # We use FieldDescriptorProto as it has standard primitive fields and nested messages. + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is None + # 'number' should be in query parameters + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_nested_field(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{options.deprecated}/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "get" + assert transcoded["uri"] == "/v1/test/True/my-field" + assert body is None + assert "number" in query_params + assert query_params["number"] == 123 + + +def test_transcode_with_body(): + http_options = [ + { + "method": "post", + "uri": "/v1/test/{name}", + "body": "options", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.options.deprecated = True + request.number = 123 + + transcoded, body, query_params = transcode_request(http_options, request) + + assert transcoded["method"] == "post" + assert transcoded["uri"] == "/v1/test/my-field" + assert body is not None + body_data = json.loads(body) + assert body_data["deprecated"] is True + # Query parameters should not contain 'options' (the body) + assert "number" in query_params + assert query_params["number"] == 123 + assert "options" not in query_params + + +def test_transcode_with_required_fields_default_values(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + + required_defaults = {"requiredQueryParam": "default-val"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["requiredQueryParam"] == "default-val" + + +def test_transcode_with_numeric_enums(): + http_options = [ + { + "method": "get", + "uri": "/v1/test/{name}", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "my-field" + request.type = descriptor_pb2.FieldDescriptorProto.TYPE_STRING + + # Without numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=False + ) + assert query_params["type"] == "TYPE_STRING" + + # With numeric enums + _, _, query_params = transcode_request( + http_options, request, rest_numeric_enums=True + ) + # Type number for TYPE_STRING is 9 + assert query_params["type"] == 9 + assert query_params["$alt"] == "json;enum-encoding=int" + + +def test_transcode_no_query_params(): + http_options = [{"method": "get", "uri": "/v1/test"}] + request = descriptor_pb2.FieldDescriptorProto() + + with mock.patch( + "google.api_core.path_template.transcode", + return_value={"method": "get", "uri": "/v1/test"}, + ): + transcoded, body, query_params = transcode_request(http_options, request) + assert query_params == {} + + +def test_transcode_with_required_fields_existing_key(): + http_options = [ + { + "method": "get", + "uri": "/v1/test", + } + ] + + request = descriptor_pb2.FieldDescriptorProto() + request.name = "custom-name" + + required_defaults = {"name": "default-name"} + + transcoded, body, query_params = transcode_request( + http_options, + request, + required_fields_default_values=required_defaults, + ) + + assert query_params["name"] == "custom-name" + + +def test_transcode_request_invalid_request(): + http_options = [{"method": "get", "uri": "/v1/test"}] + with pytest.raises(TypeError, match="request cannot be None"): + transcode_request(http_options, None) + + +def test_transcode_request_proto_plus_wrapper(): + http_options = [{"method": "get", "uri": "/v1/test/{name}"}] + mock_pb = descriptor_pb2.FieldDescriptorProto() + mock_pb.name = "proto-plus-field" + + mock_proto_plus = mock.Mock() + mock_proto_plus._pb = mock_pb + + transcoded, _, _ = transcode_request(http_options, mock_proto_plus) + assert transcoded["uri"] == "/v1/test/proto-plus-field" diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py index 33f696a4a132..65372065b01a 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py @@ -3649,17 +3649,20 @@ def test_list_jobs_rest_required_fields(request_type=storage_batch_operations.Li # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_jobs._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListJobs, + "_BaseListJobs__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_jobs._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -3708,13 +3711,6 @@ def test_list_jobs_rest_required_fields(request_type=storage_batch_operations.Li assert sorted(expected_params) == sorted(actual_params) -def test_list_jobs_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_jobs._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_jobs_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3882,16 +3878,18 @@ def test_get_job_rest_required_fields(request_type=storage_batch_operations.GetJ # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_job._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetJob, + "_BaseGetJob__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_job._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -3939,13 +3937,6 @@ def test_get_job_rest_required_fields(request_type=storage_batch_operations.GetJ assert sorted(expected_params) == sorted(actual_params) -def test_get_job_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_job._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_job_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4054,7 +4045,12 @@ def test_create_job_rest_required_fields(request_type=storage_batch_operations.C # verify fields with default values are dropped assert "jobId" not in jsonified_request - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_job._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCreateJob, + "_BaseCreateJob__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -4064,10 +4060,8 @@ def test_create_job_rest_required_fields(request_type=storage_batch_operations.C jsonified_request["parent"] = 'parent_value' jsonified_request["jobId"] = 'job_id_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).create_job._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("job_id", "request_id", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("jobId", "requestId", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -4131,13 +4125,6 @@ def test_create_job_rest_required_fields(request_type=storage_batch_operations.C assert sorted(expected_params) == sorted(actual_params) -def test_create_job_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.create_job._get_unset_required_fields({}) - assert set(unset_fields) == (set(("jobId", "requestId", )) & set(("parent", "jobId", "job", ))) - - def test_create_job_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4242,17 +4229,20 @@ def test_delete_job_rest_required_fields(request_type=storage_batch_operations.D # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_job._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseDeleteJob, + "_BaseDeleteJob__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).delete_job._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("force", "request_id", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("force", "requestId", )) # verify required fields with non-default values are left alone assert "name" in jsonified_request @@ -4309,13 +4299,6 @@ def test_delete_job_rest_required_fields(request_type=storage_batch_operations.D assert sorted(expected_params) == sorted(actual_params) -def test_delete_job_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.delete_job._get_unset_required_fields({}) - assert set(unset_fields) == (set(("force", "requestId", )) & set(("name", ))) - - def test_delete_job_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4416,16 +4399,18 @@ def test_cancel_job_rest_required_fields(request_type=storage_batch_operations.C # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).cancel_job._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseCancelJob, + "_BaseCancelJob__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).cancel_job._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -4485,13 +4470,6 @@ def test_cancel_job_rest_required_fields(request_type=storage_batch_operations.C assert sorted(expected_params) == sorted(actual_params) -def test_cancel_job_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.cancel_job._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_cancel_job_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4594,17 +4572,20 @@ def test_list_bucket_operations_rest_required_fields(request_type=storage_batch_ # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_bucket_operations._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseListBucketOperations, + "_BaseListBucketOperations__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["parent"] = 'parent_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).list_bucket_operations._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter", "order_by", "page_size", "page_token", )) - jsonified_request.update(unset_fields) + assert not set(unset_fields) - set(("filter", "orderBy", "pageSize", "pageToken", )) # verify required fields with non-default values are left alone assert "parent" in jsonified_request @@ -4653,13 +4634,6 @@ def test_list_bucket_operations_rest_required_fields(request_type=storage_batch_ assert sorted(expected_params) == sorted(actual_params) -def test_list_bucket_operations_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.list_bucket_operations._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter", "orderBy", "pageSize", "pageToken", )) & set(("parent", ))) - - def test_list_bucket_operations_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4827,16 +4801,18 @@ def test_get_bucket_operation_rest_required_fields(request_type=storage_batch_op # verify fields with default values are dropped - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_bucket_operation._get_unset_required_fields(jsonified_request) + default_values = getattr( + transport_class._BaseGetBucketOperation, + "_BaseGetBucketOperation__REQUIRED_FIELDS_DEFAULT_VALUES", + {}, + ) + unset_fields = {k: v for k, v in default_values.items() if k not in jsonified_request} jsonified_request.update(unset_fields) # verify required fields with default values are now present jsonified_request["name"] = 'name_value' - unset_fields = transport_class(credentials=ga_credentials.AnonymousCredentials()).get_bucket_operation._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == 'name_value' @@ -4884,13 +4860,6 @@ def test_get_bucket_operation_rest_required_fields(request_type=storage_batch_op assert sorted(expected_params) == sorted(actual_params) -def test_get_bucket_operation_rest_unset_required_fields(): - transport = transports.StorageBatchOperationsRestTransport(credentials=ga_credentials.AnonymousCredentials) - - unset_fields = transport.get_bucket_operation._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name", ))) - - def test_get_bucket_operation_rest_flattened(): client = StorageBatchOperationsClient( credentials=ga_credentials.AnonymousCredentials(),