diff --git a/packages/google-apps-chat/google/apps/chat/__init__.py b/packages/google-apps-chat/google/apps/chat/__init__.py index 592eb8dd77ec..b50c0acffe6f 100644 --- a/packages/google-apps-chat/google/apps/chat/__init__.py +++ b/packages/google-apps-chat/google/apps/chat/__init__.py @@ -41,6 +41,26 @@ ) from google.apps.chat_v1.types.contextual_addon import ContextualAddOnMarkup from google.apps.chat_v1.types.deletion_metadata import DeletionMetadata +from google.apps.chat_v1.types.event_payload import ( + MembershipBatchCreatedEventData, + MembershipBatchDeletedEventData, + MembershipBatchUpdatedEventData, + MembershipCreatedEventData, + MembershipDeletedEventData, + MembershipUpdatedEventData, + MessageBatchCreatedEventData, + MessageBatchDeletedEventData, + MessageBatchUpdatedEventData, + MessageCreatedEventData, + MessageDeletedEventData, + MessageUpdatedEventData, + ReactionBatchCreatedEventData, + ReactionBatchDeletedEventData, + ReactionCreatedEventData, + ReactionDeletedEventData, + SpaceBatchUpdatedEventData, + SpaceUpdatedEventData, +) from google.apps.chat_v1.types.group import Group from google.apps.chat_v1.types.history_state import HistoryState from google.apps.chat_v1.types.matched_url import MatchedUrl @@ -93,6 +113,12 @@ Space, UpdateSpaceRequest, ) +from google.apps.chat_v1.types.space_event import ( + GetSpaceEventRequest, + ListSpaceEventsRequest, + ListSpaceEventsResponse, + SpaceEvent, +) from google.apps.chat_v1.types.space_read_state import ( GetSpaceReadStateRequest, SpaceReadState, @@ -124,6 +150,24 @@ "UploadAttachmentResponse", "ContextualAddOnMarkup", "DeletionMetadata", + "MembershipBatchCreatedEventData", + "MembershipBatchDeletedEventData", + "MembershipBatchUpdatedEventData", + "MembershipCreatedEventData", + "MembershipDeletedEventData", + "MembershipUpdatedEventData", + "MessageBatchCreatedEventData", + "MessageBatchDeletedEventData", + "MessageBatchUpdatedEventData", + "MessageCreatedEventData", + "MessageDeletedEventData", + "MessageUpdatedEventData", + "ReactionBatchCreatedEventData", + "ReactionBatchDeletedEventData", + "ReactionCreatedEventData", + "ReactionDeletedEventData", + "SpaceBatchUpdatedEventData", + "SpaceUpdatedEventData", "Group", "HistoryState", "MatchedUrl", @@ -168,6 +212,10 @@ "ListSpacesResponse", "Space", "UpdateSpaceRequest", + "GetSpaceEventRequest", + "ListSpaceEventsRequest", + "ListSpaceEventsResponse", + "SpaceEvent", "GetSpaceReadStateRequest", "SpaceReadState", "UpdateSpaceReadStateRequest", diff --git a/packages/google-apps-chat/google/apps/chat/gapic_version.py b/packages/google-apps-chat/google/apps/chat/gapic_version.py index ec8d212c9160..558c8aab67c5 100644 --- a/packages/google-apps-chat/google/apps/chat/gapic_version.py +++ b/packages/google-apps-chat/google/apps/chat/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "0.1.8" # {x-release-please-version} +__version__ = "0.0.0" # {x-release-please-version} diff --git a/packages/google-apps-chat/google/apps/chat_v1/__init__.py b/packages/google-apps-chat/google/apps/chat_v1/__init__.py index d86a6dbbd7f4..94c3b6f7fef3 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/__init__.py +++ b/packages/google-apps-chat/google/apps/chat_v1/__init__.py @@ -38,6 +38,26 @@ ) from .types.contextual_addon import ContextualAddOnMarkup from .types.deletion_metadata import DeletionMetadata +from .types.event_payload import ( + MembershipBatchCreatedEventData, + MembershipBatchDeletedEventData, + MembershipBatchUpdatedEventData, + MembershipCreatedEventData, + MembershipDeletedEventData, + MembershipUpdatedEventData, + MessageBatchCreatedEventData, + MessageBatchDeletedEventData, + MessageBatchUpdatedEventData, + MessageCreatedEventData, + MessageDeletedEventData, + MessageUpdatedEventData, + ReactionBatchCreatedEventData, + ReactionBatchDeletedEventData, + ReactionCreatedEventData, + ReactionDeletedEventData, + SpaceBatchUpdatedEventData, + SpaceUpdatedEventData, +) from .types.group import Group from .types.history_state import HistoryState from .types.matched_url import MatchedUrl @@ -90,6 +110,12 @@ Space, UpdateSpaceRequest, ) +from .types.space_event import ( + GetSpaceEventRequest, + ListSpaceEventsRequest, + ListSpaceEventsResponse, + SpaceEvent, +) from .types.space_read_state import ( GetSpaceReadStateRequest, SpaceReadState, @@ -135,6 +161,7 @@ "GetAttachmentRequest", "GetMembershipRequest", "GetMessageRequest", + "GetSpaceEventRequest", "GetSpaceReadStateRequest", "GetSpaceRequest", "GetThreadReadStateRequest", @@ -146,19 +173,40 @@ "ListMessagesResponse", "ListReactionsRequest", "ListReactionsResponse", + "ListSpaceEventsRequest", + "ListSpaceEventsResponse", "ListSpacesRequest", "ListSpacesResponse", "MatchedUrl", "Membership", + "MembershipBatchCreatedEventData", + "MembershipBatchDeletedEventData", + "MembershipBatchUpdatedEventData", + "MembershipCreatedEventData", + "MembershipDeletedEventData", + "MembershipUpdatedEventData", "Message", + "MessageBatchCreatedEventData", + "MessageBatchDeletedEventData", + "MessageBatchUpdatedEventData", + "MessageCreatedEventData", + "MessageDeletedEventData", + "MessageUpdatedEventData", "QuotedMessageMetadata", "Reaction", + "ReactionBatchCreatedEventData", + "ReactionBatchDeletedEventData", + "ReactionCreatedEventData", + "ReactionDeletedEventData", "RichLinkMetadata", "SetUpSpaceRequest", "SlashCommand", "SlashCommandMetadata", "Space", + "SpaceBatchUpdatedEventData", + "SpaceEvent", "SpaceReadState", + "SpaceUpdatedEventData", "Thread", "ThreadReadState", "UpdateMembershipRequest", diff --git a/packages/google-apps-chat/google/apps/chat_v1/gapic_metadata.json b/packages/google-apps-chat/google/apps/chat_v1/gapic_metadata.json index 5bb370aac865..3cdf90b4e07e 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/gapic_metadata.json +++ b/packages/google-apps-chat/google/apps/chat_v1/gapic_metadata.json @@ -80,6 +80,11 @@ "get_space" ] }, + "GetSpaceEvent": { + "methods": [ + "get_space_event" + ] + }, "GetSpaceReadState": { "methods": [ "get_space_read_state" @@ -105,6 +110,11 @@ "list_reactions" ] }, + "ListSpaceEvents": { + "methods": [ + "list_space_events" + ] + }, "ListSpaces": { "methods": [ "list_spaces" @@ -215,6 +225,11 @@ "get_space" ] }, + "GetSpaceEvent": { + "methods": [ + "get_space_event" + ] + }, "GetSpaceReadState": { "methods": [ "get_space_read_state" @@ -240,6 +255,11 @@ "list_reactions" ] }, + "ListSpaceEvents": { + "methods": [ + "list_space_events" + ] + }, "ListSpaces": { "methods": [ "list_spaces" @@ -350,6 +370,11 @@ "get_space" ] }, + "GetSpaceEvent": { + "methods": [ + "get_space_event" + ] + }, "GetSpaceReadState": { "methods": [ "get_space_read_state" @@ -375,6 +400,11 @@ "list_reactions" ] }, + "ListSpaceEvents": { + "methods": [ + "list_space_events" + ] + }, "ListSpaces": { "methods": [ "list_spaces" diff --git a/packages/google-apps-chat/google/apps/chat_v1/gapic_version.py b/packages/google-apps-chat/google/apps/chat_v1/gapic_version.py index ec8d212c9160..558c8aab67c5 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/gapic_version.py +++ b/packages/google-apps-chat/google/apps/chat_v1/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "0.1.8" # {x-release-please-version} +__version__ = "0.0.0" # {x-release-please-version} diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/async_client.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/async_client.py index 3a998e8e296b..9208a7644885 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/async_client.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/async_client.py @@ -52,6 +52,7 @@ attachment, contextual_addon, deletion_metadata, + event_payload, group, history_state, matched_url, @@ -65,6 +66,7 @@ from google.apps.chat_v1.types import slash_command from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state from google.apps.chat_v1.types import space_setup, thread_read_state, user @@ -104,6 +106,8 @@ class ChatServiceAsyncClient: parse_reaction_path = staticmethod(ChatServiceClient.parse_reaction_path) space_path = staticmethod(ChatServiceClient.space_path) parse_space_path = staticmethod(ChatServiceClient.parse_space_path) + space_event_path = staticmethod(ChatServiceClient.space_event_path) + parse_space_event_path = staticmethod(ChatServiceClient.parse_space_event_path) space_read_state_path = staticmethod(ChatServiceClient.space_read_state_path) parse_space_read_state_path = staticmethod( ChatServiceClient.parse_space_read_state_path @@ -3572,6 +3576,333 @@ async def sample_get_thread_read_state(): # Done; return the response. return response + async def get_space_event( + self, + request: Optional[Union[space_event.GetSpaceEventRequest, dict]] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> space_event.SpaceEvent: + r"""Returns an event from a Google Chat space. The `event + payload `__ + contains the most recent version of the resource that changed. + For example, if you request an event about a new message but the + message was later updated, the server returns the updated + ``Message`` resource in the event payload. + + Requires `user + authentication `__. + To get an event, the authenticated user must be a member of the + space. + + For an example, see `Get details about an event from a Google + Chat + space `__. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.apps import chat_v1 + + async def sample_get_space_event(): + # Create a client + client = chat_v1.ChatServiceAsyncClient() + + # Initialize request argument(s) + request = chat_v1.GetSpaceEventRequest( + name="name_value", + ) + + # Make the request + response = await client.get_space_event(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.apps.chat_v1.types.GetSpaceEventRequest, dict]]): + The request object. Request message for getting a space + event. + name (:class:`str`): + Required. The resource name of the space event. + + Format: ``spaces/{space}/spaceEvents/{spaceEvent}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.apps.chat_v1.types.SpaceEvent: + An event that represents a change or activity in a Google Chat space. To + learn more, see [Work with events from Google + Chat](\ https://developers.google.com/workspace/chat/events-overview). + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([name]) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, space_event.GetSpaceEventRequest): + request = space_event.GetSpaceEventRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.get_space_event + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_space_events( + self, + request: Optional[Union[space_event.ListSpaceEventsRequest, dict]] = None, + *, + parent: Optional[str] = None, + filter: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListSpaceEventsAsyncPager: + r"""Lists events from a Google Chat space. For each event, the + `payload `__ + contains the most recent version of the Chat resource. For + example, if you list events about new space members, the server + returns ``Membership`` resources that contain the latest + membership details. If new members were removed during the + requested period, the event payload contains an empty + ``Membership`` resource. + + Requires `user + authentication `__. + To list events, the authenticated user must be a member of the + space. + + For an example, see `List events from a Google Chat + space `__. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.apps import chat_v1 + + async def sample_list_space_events(): + # Create a client + client = chat_v1.ChatServiceAsyncClient() + + # Initialize request argument(s) + request = chat_v1.ListSpaceEventsRequest( + parent="parent_value", + filter="filter_value", + ) + + # Make the request + page_result = client.list_space_events(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.apps.chat_v1.types.ListSpaceEventsRequest, dict]]): + The request object. Request message for listing space + events. + parent (:class:`str`): + Required. Resource name of the `Google Chat + space `__ + where the events occurred. + + Format: ``spaces/{space}``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + filter (:class:`str`): + Required. A query filter. + + You must specify at least one event type + (``event_type``) using the has ``:`` operator. To filter + by multiple event types, use the ``OR`` operator. Omit + batch event types in your filter. The request + automatically returns any related batch events. For + example, if you filter by new reactions + (``google.workspace.chat.reaction.v1.created``), the + server also returns batch new reactions events + (``google.workspace.chat.reaction.v1.batchCreated``). + For a list of supported event types, see the + ```SpaceEvents`` reference + documentation `__. + + Optionally, you can also filter by start time + (``start_time``) and end time (``end_time``): + + - ``start_time``: Exclusive timestamp from which to + start listing space events. You can list events that + occurred up to 28 days ago. If unspecified, lists + space events from the past 28 days. + - ``end_time``: Inclusive timestamp until which space + events are listed. If unspecified, lists events up to + the time of the request. + + To specify a start or end time, use the equals ``=`` + operator and format in + `RFC-3339 `__. + To filter by both ``start_time`` and ``end_time``, use + the ``AND`` operator. + + For example, the following queries are valid: + + :: + + start_time="2023-08-23T19:20:33+00:00" AND + end_time="2023-08-23T19:21:54+00:00" + + :: + + start_time="2023-08-23T19:20:33+00:00" AND + (event_types:"google.workspace.chat.space.v1.updated" OR + event_types:"google.workspace.chat.message.v1.created") + + The following queries are invalid: + + :: + + start_time="2023-08-23T19:20:33+00:00" OR + end_time="2023-08-23T19:21:54+00:00" + + :: + + event_types:"google.workspace.chat.space.v1.updated" AND + event_types:"google.workspace.chat.message.v1.created" + + Invalid queries are rejected by the server with an + ``INVALID_ARGUMENT`` error. + + This corresponds to the ``filter`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.apps.chat_v1.services.chat_service.pagers.ListSpaceEventsAsyncPager: + Response message for listing space + events. + Iterating over this object will yield + results and resolve additional pages + automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([parent, filter]) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, space_event.ListSpaceEventsRequest): + request = space_event.ListSpaceEventsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if filter is not None: + request.filter = filter + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.list_space_events + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListSpaceEventsAsyncPager( + method=rpc, + request=request, + response=response, + metadata=metadata, + ) + + # Done; return the response. + return response + async def __aenter__(self) -> "ChatServiceAsyncClient": return self diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/client.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/client.py index d411ccc0b2a0..3d71e3dce742 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/client.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/client.py @@ -57,6 +57,7 @@ attachment, contextual_addon, deletion_metadata, + event_payload, group, history_state, matched_url, @@ -70,6 +71,7 @@ from google.apps.chat_v1.types import slash_command from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state from google.apps.chat_v1.types import space_setup, thread_read_state, user @@ -321,6 +323,23 @@ def parse_space_path(path: str) -> Dict[str, str]: m = re.match(r"^spaces/(?P.+?)$", path) return m.groupdict() if m else {} + @staticmethod + def space_event_path( + space: str, + space_event: str, + ) -> str: + """Returns a fully-qualified space_event string.""" + return "spaces/{space}/spaceEvents/{space_event}".format( + space=space, + space_event=space_event, + ) + + @staticmethod + def parse_space_event_path(path: str) -> Dict[str, str]: + """Parses a space_event path into its component segments.""" + m = re.match(r"^spaces/(?P.+?)/spaceEvents/(?P.+?)$", path) + return m.groupdict() if m else {} + @staticmethod def space_read_state_path( user: str, @@ -4045,6 +4064,327 @@ def sample_get_thread_read_state(): # Done; return the response. return response + def get_space_event( + self, + request: Optional[Union[space_event.GetSpaceEventRequest, dict]] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> space_event.SpaceEvent: + r"""Returns an event from a Google Chat space. The `event + payload `__ + contains the most recent version of the resource that changed. + For example, if you request an event about a new message but the + message was later updated, the server returns the updated + ``Message`` resource in the event payload. + + Requires `user + authentication `__. + To get an event, the authenticated user must be a member of the + space. + + For an example, see `Get details about an event from a Google + Chat + space `__. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.apps import chat_v1 + + def sample_get_space_event(): + # Create a client + client = chat_v1.ChatServiceClient() + + # Initialize request argument(s) + request = chat_v1.GetSpaceEventRequest( + name="name_value", + ) + + # Make the request + response = client.get_space_event(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.apps.chat_v1.types.GetSpaceEventRequest, dict]): + The request object. Request message for getting a space + event. + name (str): + Required. The resource name of the space event. + + Format: ``spaces/{space}/spaceEvents/{spaceEvent}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.apps.chat_v1.types.SpaceEvent: + An event that represents a change or activity in a Google Chat space. To + learn more, see [Work with events from Google + Chat](\ https://developers.google.com/workspace/chat/events-overview). + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([name]) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, space_event.GetSpaceEventRequest): + request = space_event.GetSpaceEventRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_space_event] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def list_space_events( + self, + request: Optional[Union[space_event.ListSpaceEventsRequest, dict]] = None, + *, + parent: Optional[str] = None, + filter: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListSpaceEventsPager: + r"""Lists events from a Google Chat space. For each event, the + `payload `__ + contains the most recent version of the Chat resource. For + example, if you list events about new space members, the server + returns ``Membership`` resources that contain the latest + membership details. If new members were removed during the + requested period, the event payload contains an empty + ``Membership`` resource. + + Requires `user + authentication `__. + To list events, the authenticated user must be a member of the + space. + + For an example, see `List events from a Google Chat + space `__. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.apps import chat_v1 + + def sample_list_space_events(): + # Create a client + client = chat_v1.ChatServiceClient() + + # Initialize request argument(s) + request = chat_v1.ListSpaceEventsRequest( + parent="parent_value", + filter="filter_value", + ) + + # Make the request + page_result = client.list_space_events(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.apps.chat_v1.types.ListSpaceEventsRequest, dict]): + The request object. Request message for listing space + events. + parent (str): + Required. Resource name of the `Google Chat + space `__ + where the events occurred. + + Format: ``spaces/{space}``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + filter (str): + Required. A query filter. + + You must specify at least one event type + (``event_type``) using the has ``:`` operator. To filter + by multiple event types, use the ``OR`` operator. Omit + batch event types in your filter. The request + automatically returns any related batch events. For + example, if you filter by new reactions + (``google.workspace.chat.reaction.v1.created``), the + server also returns batch new reactions events + (``google.workspace.chat.reaction.v1.batchCreated``). + For a list of supported event types, see the + ```SpaceEvents`` reference + documentation `__. + + Optionally, you can also filter by start time + (``start_time``) and end time (``end_time``): + + - ``start_time``: Exclusive timestamp from which to + start listing space events. You can list events that + occurred up to 28 days ago. If unspecified, lists + space events from the past 28 days. + - ``end_time``: Inclusive timestamp until which space + events are listed. If unspecified, lists events up to + the time of the request. + + To specify a start or end time, use the equals ``=`` + operator and format in + `RFC-3339 `__. + To filter by both ``start_time`` and ``end_time``, use + the ``AND`` operator. + + For example, the following queries are valid: + + :: + + start_time="2023-08-23T19:20:33+00:00" AND + end_time="2023-08-23T19:21:54+00:00" + + :: + + start_time="2023-08-23T19:20:33+00:00" AND + (event_types:"google.workspace.chat.space.v1.updated" OR + event_types:"google.workspace.chat.message.v1.created") + + The following queries are invalid: + + :: + + start_time="2023-08-23T19:20:33+00:00" OR + end_time="2023-08-23T19:21:54+00:00" + + :: + + event_types:"google.workspace.chat.space.v1.updated" AND + event_types:"google.workspace.chat.message.v1.created" + + Invalid queries are rejected by the server with an + ``INVALID_ARGUMENT`` error. + + This corresponds to the ``filter`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.apps.chat_v1.services.chat_service.pagers.ListSpaceEventsPager: + Response message for listing space + events. + Iterating over this object will yield + results and resolve additional pages + automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([parent, filter]) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, space_event.ListSpaceEventsRequest): + request = space_event.ListSpaceEventsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if filter is not None: + request.filter = filter + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_space_events] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListSpaceEventsPager( + method=rpc, + request=request, + response=response, + metadata=metadata, + ) + + # Done; return the response. + return response + def __enter__(self) -> "ChatServiceClient": return self diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/pagers.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/pagers.py index 50c9467efccc..6b76806600a5 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/pagers.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/pagers.py @@ -24,7 +24,7 @@ Tuple, ) -from google.apps.chat_v1.types import membership, message, reaction, space +from google.apps.chat_v1.types import membership, message, reaction, space, space_event class ListMessagesPager: @@ -537,3 +537,131 @@ async def async_generator(): def __repr__(self) -> str: return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListSpaceEventsPager: + """A pager for iterating through ``list_space_events`` requests. + + This class thinly wraps an initial + :class:`google.apps.chat_v1.types.ListSpaceEventsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``space_events`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListSpaceEvents`` requests and continue to iterate + through the ``space_events`` field on the + corresponding responses. + + All the usual :class:`google.apps.chat_v1.types.ListSpaceEventsResponse` + attributes are available on the pager. If multiple requests are made, only + the most recent response is retained, and thus used for attribute lookup. + """ + + def __init__( + self, + method: Callable[..., space_event.ListSpaceEventsResponse], + request: space_event.ListSpaceEventsRequest, + response: space_event.ListSpaceEventsResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.apps.chat_v1.types.ListSpaceEventsRequest): + The initial request object. + response (google.apps.chat_v1.types.ListSpaceEventsResponse): + The initial response object. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + """ + self._method = method + self._request = space_event.ListSpaceEventsRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[space_event.ListSpaceEventsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method(self._request, metadata=self._metadata) + yield self._response + + def __iter__(self) -> Iterator[space_event.SpaceEvent]: + for page in self.pages: + yield from page.space_events + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListSpaceEventsAsyncPager: + """A pager for iterating through ``list_space_events`` requests. + + This class thinly wraps an initial + :class:`google.apps.chat_v1.types.ListSpaceEventsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``space_events`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListSpaceEvents`` requests and continue to iterate + through the ``space_events`` field on the + corresponding responses. + + All the usual :class:`google.apps.chat_v1.types.ListSpaceEventsResponse` + attributes are available on the pager. If multiple requests are made, only + the most recent response is retained, and thus used for attribute lookup. + """ + + def __init__( + self, + method: Callable[..., Awaitable[space_event.ListSpaceEventsResponse]], + request: space_event.ListSpaceEventsRequest, + response: space_event.ListSpaceEventsResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.apps.chat_v1.types.ListSpaceEventsRequest): + The initial request object. + response (google.apps.chat_v1.types.ListSpaceEventsResponse): + The initial response object. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + """ + self._method = method + self._request = space_event.ListSpaceEventsRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages(self) -> AsyncIterator[space_event.ListSpaceEventsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = await self._method(self._request, metadata=self._metadata) + yield self._response + + def __aiter__(self) -> AsyncIterator[space_event.SpaceEvent]: + async def async_generator(): + async for page in self.pages: + for response in page.space_events: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/base.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/base.py index 543b1a31874c..e5b32aaf272b 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/base.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/base.py @@ -35,6 +35,7 @@ from google.apps.chat_v1.types import reaction as gc_reaction from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state from google.apps.chat_v1.types import space_setup, thread_read_state @@ -527,6 +528,34 @@ def _prep_wrapped_messages(self, client_info): default_timeout=30.0, client_info=client_info, ), + self.get_space_event: gapic_v1.method.wrap_method( + self.get_space_event, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=30.0, + ), + default_timeout=30.0, + client_info=client_info, + ), + self.list_space_events: gapic_v1.method.wrap_method( + self.list_space_events, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=30.0, + ), + default_timeout=30.0, + client_info=client_info, + ), } def close(self): @@ -782,6 +811,27 @@ def get_thread_read_state( ]: raise NotImplementedError() + @property + def get_space_event( + self, + ) -> Callable[ + [space_event.GetSpaceEventRequest], + Union[space_event.SpaceEvent, Awaitable[space_event.SpaceEvent]], + ]: + raise NotImplementedError() + + @property + def list_space_events( + self, + ) -> Callable[ + [space_event.ListSpaceEventsRequest], + Union[ + space_event.ListSpaceEventsResponse, + Awaitable[space_event.ListSpaceEventsResponse], + ], + ]: + raise NotImplementedError() + @property def kind(self) -> str: raise NotImplementedError() diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc.py index 6e36385be192..2ef3b8c317bb 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc.py @@ -32,6 +32,7 @@ from google.apps.chat_v1.types import reaction as gc_reaction from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state from google.apps.chat_v1.types import space_setup, thread_read_state @@ -1227,6 +1228,89 @@ def get_thread_read_state( ) return self._stubs["get_thread_read_state"] + @property + def get_space_event( + self, + ) -> Callable[[space_event.GetSpaceEventRequest], space_event.SpaceEvent]: + r"""Return a callable for the get space event method over gRPC. + + Returns an event from a Google Chat space. The `event + payload `__ + contains the most recent version of the resource that changed. + For example, if you request an event about a new message but the + message was later updated, the server returns the updated + ``Message`` resource in the event payload. + + Requires `user + authentication `__. + To get an event, the authenticated user must be a member of the + space. + + For an example, see `Get details about an event from a Google + Chat + space `__. + + Returns: + Callable[[~.GetSpaceEventRequest], + ~.SpaceEvent]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_space_event" not in self._stubs: + self._stubs["get_space_event"] = self.grpc_channel.unary_unary( + "/google.chat.v1.ChatService/GetSpaceEvent", + request_serializer=space_event.GetSpaceEventRequest.serialize, + response_deserializer=space_event.SpaceEvent.deserialize, + ) + return self._stubs["get_space_event"] + + @property + def list_space_events( + self, + ) -> Callable[ + [space_event.ListSpaceEventsRequest], space_event.ListSpaceEventsResponse + ]: + r"""Return a callable for the list space events method over gRPC. + + Lists events from a Google Chat space. For each event, the + `payload `__ + contains the most recent version of the Chat resource. For + example, if you list events about new space members, the server + returns ``Membership`` resources that contain the latest + membership details. If new members were removed during the + requested period, the event payload contains an empty + ``Membership`` resource. + + Requires `user + authentication `__. + To list events, the authenticated user must be a member of the + space. + + For an example, see `List events from a Google Chat + space `__. + + Returns: + Callable[[~.ListSpaceEventsRequest], + ~.ListSpaceEventsResponse]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "list_space_events" not in self._stubs: + self._stubs["list_space_events"] = self.grpc_channel.unary_unary( + "/google.chat.v1.ChatService/ListSpaceEvents", + request_serializer=space_event.ListSpaceEventsRequest.serialize, + response_deserializer=space_event.ListSpaceEventsResponse.deserialize, + ) + return self._stubs["list_space_events"] + def close(self): self.grpc_channel.close() diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc_asyncio.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc_asyncio.py index fb2a66bc013c..e36b81f08a6c 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc_asyncio.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/grpc_asyncio.py @@ -34,6 +34,7 @@ from google.apps.chat_v1.types import reaction as gc_reaction from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state from google.apps.chat_v1.types import space_setup, thread_read_state @@ -1255,6 +1256,92 @@ def get_thread_read_state( ) return self._stubs["get_thread_read_state"] + @property + def get_space_event( + self, + ) -> Callable[ + [space_event.GetSpaceEventRequest], Awaitable[space_event.SpaceEvent] + ]: + r"""Return a callable for the get space event method over gRPC. + + Returns an event from a Google Chat space. The `event + payload `__ + contains the most recent version of the resource that changed. + For example, if you request an event about a new message but the + message was later updated, the server returns the updated + ``Message`` resource in the event payload. + + Requires `user + authentication `__. + To get an event, the authenticated user must be a member of the + space. + + For an example, see `Get details about an event from a Google + Chat + space `__. + + Returns: + Callable[[~.GetSpaceEventRequest], + Awaitable[~.SpaceEvent]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_space_event" not in self._stubs: + self._stubs["get_space_event"] = self.grpc_channel.unary_unary( + "/google.chat.v1.ChatService/GetSpaceEvent", + request_serializer=space_event.GetSpaceEventRequest.serialize, + response_deserializer=space_event.SpaceEvent.deserialize, + ) + return self._stubs["get_space_event"] + + @property + def list_space_events( + self, + ) -> Callable[ + [space_event.ListSpaceEventsRequest], + Awaitable[space_event.ListSpaceEventsResponse], + ]: + r"""Return a callable for the list space events method over gRPC. + + Lists events from a Google Chat space. For each event, the + `payload `__ + contains the most recent version of the Chat resource. For + example, if you list events about new space members, the server + returns ``Membership`` resources that contain the latest + membership details. If new members were removed during the + requested period, the event payload contains an empty + ``Membership`` resource. + + Requires `user + authentication `__. + To list events, the authenticated user must be a member of the + space. + + For an example, see `List events from a Google Chat + space `__. + + Returns: + Callable[[~.ListSpaceEventsRequest], + Awaitable[~.ListSpaceEventsResponse]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "list_space_events" not in self._stubs: + self._stubs["list_space_events"] = self.grpc_channel.unary_unary( + "/google.chat.v1.ChatService/ListSpaceEvents", + request_serializer=space_event.ListSpaceEventsRequest.serialize, + response_deserializer=space_event.ListSpaceEventsResponse.deserialize, + ) + return self._stubs["list_space_events"] + def _prep_wrapped_messages(self, client_info): """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" self._wrapped_methods = { @@ -1622,6 +1709,34 @@ def _prep_wrapped_messages(self, client_info): default_timeout=30.0, client_info=client_info, ), + self.get_space_event: gapic_v1.method_async.wrap_method( + self.get_space_event, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=30.0, + ), + default_timeout=30.0, + client_info=client_info, + ), + self.list_space_events: gapic_v1.method_async.wrap_method( + self.list_space_events, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=30.0, + ), + default_timeout=30.0, + client_info=client_info, + ), } def close(self): diff --git a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/rest.py b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/rest.py index 007d09119f6a..87947ff116c8 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/rest.py +++ b/packages/google-apps-chat/google/apps/chat_v1/services/chat_service/transports/rest.py @@ -47,6 +47,7 @@ from google.apps.chat_v1.types import reaction as gc_reaction from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state from google.apps.chat_v1.types import space_setup, thread_read_state @@ -176,6 +177,14 @@ def post_get_space(self, response): logging.log(f"Received response: {response}") return response + def pre_get_space_event(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_space_event(self, response): + logging.log(f"Received response: {response}") + return response + def pre_get_space_read_state(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -216,6 +225,14 @@ def post_list_reactions(self, response): logging.log(f"Received response: {response}") return response + def pre_list_space_events(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_space_events(self, response): + logging.log(f"Received response: {response}") + return response + def pre_list_spaces(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -547,6 +564,29 @@ def post_get_space(self, response: space.Space) -> space.Space: """ return response + def pre_get_space_event( + self, + request: space_event.GetSpaceEventRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[space_event.GetSpaceEventRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_space_event + + Override in a subclass to manipulate the request or metadata + before they are sent to the ChatService server. + """ + return request, metadata + + def post_get_space_event( + self, response: space_event.SpaceEvent + ) -> space_event.SpaceEvent: + """Post-rpc interceptor for get_space_event + + Override in a subclass to manipulate the response + after it is returned by the ChatService server but before + it is returned to user code. + """ + return response + def pre_get_space_read_state( self, request: space_read_state.GetSpaceReadStateRequest, @@ -660,6 +700,29 @@ def post_list_reactions( """ return response + def pre_list_space_events( + self, + request: space_event.ListSpaceEventsRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[space_event.ListSpaceEventsRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_space_events + + Override in a subclass to manipulate the request or metadata + before they are sent to the ChatService server. + """ + return request, metadata + + def post_list_space_events( + self, response: space_event.ListSpaceEventsResponse + ) -> space_event.ListSpaceEventsResponse: + """Post-rpc interceptor for list_space_events + + Override in a subclass to manipulate the response + after it is returned by the ChatService server but before + it is returned to user code. + """ + return response + def pre_list_spaces( self, request: space.ListSpacesRequest, metadata: Sequence[Tuple[str, str]] ) -> Tuple[space.ListSpacesRequest, Sequence[Tuple[str, str]]]: @@ -2141,6 +2204,96 @@ def __call__( resp = self._interceptor.post_get_space(resp) return resp + class _GetSpaceEvent(ChatServiceRestStub): + def __hash__(self): + return hash("GetSpaceEvent") + + __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 + } + + def __call__( + self, + request: space_event.GetSpaceEventRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> space_event.SpaceEvent: + r"""Call the get space event method over HTTP. + + Args: + request (~.space_event.GetSpaceEventRequest): + The request object. Request message for getting a space + event. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.space_event.SpaceEvent: + An event that represents a change or activity in a + Google Chat space. To learn more, see `Work with events + from Google + Chat `__. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=spaces/*/spaceEvents/*}", + }, + ] + request, metadata = self._interceptor.pre_get_space_event(request, metadata) + pb_request = space_event.GetSpaceEventRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + query_params["$alt"] = "json;enum-encoding=int" + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = space_event.SpaceEvent() + pb_resp = space_event.SpaceEvent.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_space_event(resp) + return resp + class _GetSpaceReadState(ChatServiceRestStub): def __hash__(self): return hash("GetSpaceReadState") @@ -2586,6 +2739,98 @@ def __call__( resp = self._interceptor.post_list_reactions(resp) return resp + class _ListSpaceEvents(ChatServiceRestStub): + def __hash__(self): + return hash("ListSpaceEvents") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "filter": "", + } + + @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 + } + + def __call__( + self, + request: space_event.ListSpaceEventsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> space_event.ListSpaceEventsResponse: + r"""Call the list space events method over HTTP. + + Args: + request (~.space_event.ListSpaceEventsRequest): + The request object. Request message for listing space + events. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.space_event.ListSpaceEventsResponse: + Response message for listing space + events. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=spaces/*}/spaceEvents", + }, + ] + request, metadata = self._interceptor.pre_list_space_events( + request, metadata + ) + pb_request = space_event.ListSpaceEventsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + query_params["$alt"] = "json;enum-encoding=int" + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = space_event.ListSpaceEventsResponse() + pb_resp = space_event.ListSpaceEventsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_space_events(resp) + return resp + class _ListSpaces(ChatServiceRestStub): def __hash__(self): return hash("ListSpaces") @@ -3354,6 +3599,14 @@ def get_space(self) -> Callable[[space.GetSpaceRequest], space.Space]: # In C++ this would require a dynamic_cast return self._GetSpace(self._session, self._host, self._interceptor) # type: ignore + @property + def get_space_event( + self, + ) -> Callable[[space_event.GetSpaceEventRequest], space_event.SpaceEvent]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetSpaceEvent(self._session, self._host, self._interceptor) # type: ignore + @property def get_space_read_state( self, @@ -3400,6 +3653,16 @@ def list_reactions( # In C++ this would require a dynamic_cast return self._ListReactions(self._session, self._host, self._interceptor) # type: ignore + @property + def list_space_events( + self, + ) -> Callable[ + [space_event.ListSpaceEventsRequest], space_event.ListSpaceEventsResponse + ]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListSpaceEvents(self._session, self._host, self._interceptor) # type: ignore + @property def list_spaces( self, diff --git a/packages/google-apps-chat/google/apps/chat_v1/types/__init__.py b/packages/google-apps-chat/google/apps/chat_v1/types/__init__.py index d1e75a782add..e47046db19af 100644 --- a/packages/google-apps-chat/google/apps/chat_v1/types/__init__.py +++ b/packages/google-apps-chat/google/apps/chat_v1/types/__init__.py @@ -32,6 +32,26 @@ ) from .contextual_addon import ContextualAddOnMarkup from .deletion_metadata import DeletionMetadata +from .event_payload import ( + MembershipBatchCreatedEventData, + MembershipBatchDeletedEventData, + MembershipBatchUpdatedEventData, + MembershipCreatedEventData, + MembershipDeletedEventData, + MembershipUpdatedEventData, + MessageBatchCreatedEventData, + MessageBatchDeletedEventData, + MessageBatchUpdatedEventData, + MessageCreatedEventData, + MessageDeletedEventData, + MessageUpdatedEventData, + ReactionBatchCreatedEventData, + ReactionBatchDeletedEventData, + ReactionCreatedEventData, + ReactionDeletedEventData, + SpaceBatchUpdatedEventData, + SpaceUpdatedEventData, +) from .group import Group from .history_state import HistoryState from .matched_url import MatchedUrl @@ -84,6 +104,12 @@ Space, UpdateSpaceRequest, ) +from .space_event import ( + GetSpaceEventRequest, + ListSpaceEventsRequest, + ListSpaceEventsResponse, + SpaceEvent, +) from .space_read_state import ( GetSpaceReadStateRequest, SpaceReadState, @@ -110,6 +136,24 @@ "UploadAttachmentResponse", "ContextualAddOnMarkup", "DeletionMetadata", + "MembershipBatchCreatedEventData", + "MembershipBatchDeletedEventData", + "MembershipBatchUpdatedEventData", + "MembershipCreatedEventData", + "MembershipDeletedEventData", + "MembershipUpdatedEventData", + "MessageBatchCreatedEventData", + "MessageBatchDeletedEventData", + "MessageBatchUpdatedEventData", + "MessageCreatedEventData", + "MessageDeletedEventData", + "MessageUpdatedEventData", + "ReactionBatchCreatedEventData", + "ReactionBatchDeletedEventData", + "ReactionCreatedEventData", + "ReactionDeletedEventData", + "SpaceBatchUpdatedEventData", + "SpaceUpdatedEventData", "Group", "HistoryState", "MatchedUrl", @@ -154,6 +198,10 @@ "ListSpacesResponse", "Space", "UpdateSpaceRequest", + "GetSpaceEventRequest", + "ListSpaceEventsRequest", + "ListSpaceEventsResponse", + "SpaceEvent", "GetSpaceReadStateRequest", "SpaceReadState", "UpdateSpaceReadStateRequest", diff --git a/packages/google-apps-chat/google/apps/chat_v1/types/event_payload.py b/packages/google-apps-chat/google/apps/chat_v1/types/event_payload.py new file mode 100644 index 000000000000..7d5fdc7bd9dd --- /dev/null +++ b/packages/google-apps-chat/google/apps/chat_v1/types/event_payload.py @@ -0,0 +1,361 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import annotations + +from typing import MutableMapping, MutableSequence + +import proto # type: ignore + +from google.apps.chat_v1.types import membership as gc_membership +from google.apps.chat_v1.types import message as gc_message +from google.apps.chat_v1.types import reaction as gc_reaction +from google.apps.chat_v1.types import space as gc_space + +__protobuf__ = proto.module( + package="google.chat.v1", + manifest={ + "MembershipCreatedEventData", + "MembershipDeletedEventData", + "MembershipUpdatedEventData", + "MembershipBatchCreatedEventData", + "MembershipBatchUpdatedEventData", + "MembershipBatchDeletedEventData", + "MessageCreatedEventData", + "MessageUpdatedEventData", + "MessageDeletedEventData", + "MessageBatchCreatedEventData", + "MessageBatchUpdatedEventData", + "MessageBatchDeletedEventData", + "SpaceUpdatedEventData", + "SpaceBatchUpdatedEventData", + "ReactionCreatedEventData", + "ReactionDeletedEventData", + "ReactionBatchCreatedEventData", + "ReactionBatchDeletedEventData", + }, +) + + +class MembershipCreatedEventData(proto.Message): + r"""Event payload for a new membership. + + Event type: ``google.workspace.chat.membership.v1.created``. + + Attributes: + membership (google.apps.chat_v1.types.Membership): + The new membership. + """ + + membership: gc_membership.Membership = proto.Field( + proto.MESSAGE, + number=1, + message=gc_membership.Membership, + ) + + +class MembershipDeletedEventData(proto.Message): + r"""Event payload for a deleted membership. + + Event type: ``google.workspace.chat.membership.v1.deleted`` + + Attributes: + membership (google.apps.chat_v1.types.Membership): + The deleted membership. Only the ``name`` and ``state`` + fields are populated. + """ + + membership: gc_membership.Membership = proto.Field( + proto.MESSAGE, + number=1, + message=gc_membership.Membership, + ) + + +class MembershipUpdatedEventData(proto.Message): + r"""Event payload for an updated membership. + + Event type: ``google.workspace.chat.membership.v1.updated`` + + Attributes: + membership (google.apps.chat_v1.types.Membership): + The updated membership. + """ + + membership: gc_membership.Membership = proto.Field( + proto.MESSAGE, + number=1, + message=gc_membership.Membership, + ) + + +class MembershipBatchCreatedEventData(proto.Message): + r"""Event payload for multiple new memberships. + + Event type: ``google.workspace.chat.membership.v1.batchCreated`` + + Attributes: + memberships (MutableSequence[google.apps.chat_v1.types.MembershipCreatedEventData]): + A list of new memberships. + """ + + memberships: MutableSequence["MembershipCreatedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="MembershipCreatedEventData", + ) + + +class MembershipBatchUpdatedEventData(proto.Message): + r"""Event payload for multiple updated memberships. + + Event type: ``google.workspace.chat.membership.v1.batchUpdated`` + + Attributes: + memberships (MutableSequence[google.apps.chat_v1.types.MembershipUpdatedEventData]): + A list of updated memberships. + """ + + memberships: MutableSequence["MembershipUpdatedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="MembershipUpdatedEventData", + ) + + +class MembershipBatchDeletedEventData(proto.Message): + r"""Event payload for multiple deleted memberships. + + Event type: ``google.workspace.chat.membership.v1.batchDeleted`` + + Attributes: + memberships (MutableSequence[google.apps.chat_v1.types.MembershipDeletedEventData]): + A list of deleted memberships. + """ + + memberships: MutableSequence["MembershipDeletedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="MembershipDeletedEventData", + ) + + +class MessageCreatedEventData(proto.Message): + r"""Event payload for a new message. + + Event type: ``google.workspace.chat.message.v1.created`` + + Attributes: + message (google.apps.chat_v1.types.Message): + The new message. + """ + + message: gc_message.Message = proto.Field( + proto.MESSAGE, + number=1, + message=gc_message.Message, + ) + + +class MessageUpdatedEventData(proto.Message): + r"""Event payload for an updated message. + + Event type: ``google.workspace.chat.message.v1.updated`` + + Attributes: + message (google.apps.chat_v1.types.Message): + The updated message. + """ + + message: gc_message.Message = proto.Field( + proto.MESSAGE, + number=1, + message=gc_message.Message, + ) + + +class MessageDeletedEventData(proto.Message): + r"""Event payload for a deleted message. + + Event type: ``google.workspace.chat.message.v1.deleted`` + + Attributes: + message (google.apps.chat_v1.types.Message): + The deleted message. Only the ``name``, ``createTime``, + ``deleteTime``, and ``deletionMetadata`` fields are + populated. + """ + + message: gc_message.Message = proto.Field( + proto.MESSAGE, + number=1, + message=gc_message.Message, + ) + + +class MessageBatchCreatedEventData(proto.Message): + r"""Event payload for multiple new messages. + + Event type: ``google.workspace.chat.message.v1.batchCreated`` + + Attributes: + messages (MutableSequence[google.apps.chat_v1.types.MessageCreatedEventData]): + A list of new messages. + """ + + messages: MutableSequence["MessageCreatedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="MessageCreatedEventData", + ) + + +class MessageBatchUpdatedEventData(proto.Message): + r"""Event payload for multiple updated messages. + + Event type: ``google.workspace.chat.message.v1.batchUpdated`` + + Attributes: + messages (MutableSequence[google.apps.chat_v1.types.MessageUpdatedEventData]): + A list of updated messages. + """ + + messages: MutableSequence["MessageUpdatedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="MessageUpdatedEventData", + ) + + +class MessageBatchDeletedEventData(proto.Message): + r"""Event payload for multiple deleted messages. + + Event type: ``google.workspace.chat.message.v1.batchDeleted`` + + Attributes: + messages (MutableSequence[google.apps.chat_v1.types.MessageDeletedEventData]): + A list of deleted messages. + """ + + messages: MutableSequence["MessageDeletedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="MessageDeletedEventData", + ) + + +class SpaceUpdatedEventData(proto.Message): + r"""Event payload for an updated space. + + Event type: ``google.workspace.chat.space.v1.updated`` + + Attributes: + space (google.apps.chat_v1.types.Space): + The updated space. + """ + + space: gc_space.Space = proto.Field( + proto.MESSAGE, + number=1, + message=gc_space.Space, + ) + + +class SpaceBatchUpdatedEventData(proto.Message): + r"""Event payload for multiple updates to a space. + + Event type: ``google.workspace.chat.space.v1.batchUpdated`` + + Attributes: + spaces (MutableSequence[google.apps.chat_v1.types.SpaceUpdatedEventData]): + A list of updated spaces. + """ + + spaces: MutableSequence["SpaceUpdatedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="SpaceUpdatedEventData", + ) + + +class ReactionCreatedEventData(proto.Message): + r"""Event payload for a new reaction. + + Event type: ``google.workspace.chat.reaction.v1.created`` + + Attributes: + reaction (google.apps.chat_v1.types.Reaction): + The new reaction. + """ + + reaction: gc_reaction.Reaction = proto.Field( + proto.MESSAGE, + number=1, + message=gc_reaction.Reaction, + ) + + +class ReactionDeletedEventData(proto.Message): + r"""Event payload for a deleted reaction. + + Type: ``google.workspace.chat.reaction.v1.deleted`` + + Attributes: + reaction (google.apps.chat_v1.types.Reaction): + The deleted reaction. + """ + + reaction: gc_reaction.Reaction = proto.Field( + proto.MESSAGE, + number=1, + message=gc_reaction.Reaction, + ) + + +class ReactionBatchCreatedEventData(proto.Message): + r"""Event payload for multiple new reactions. + + Event type: ``google.workspace.chat.reaction.v1.batchCreated`` + + Attributes: + reactions (MutableSequence[google.apps.chat_v1.types.ReactionCreatedEventData]): + A list of new reactions. + """ + + reactions: MutableSequence["ReactionCreatedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="ReactionCreatedEventData", + ) + + +class ReactionBatchDeletedEventData(proto.Message): + r"""Event payload for multiple deleted reactions. + + Event type: ``google.workspace.chat.reaction.v1.batchDeleted`` + + Attributes: + reactions (MutableSequence[google.apps.chat_v1.types.ReactionDeletedEventData]): + A list of deleted reactions. + """ + + reactions: MutableSequence["ReactionDeletedEventData"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="ReactionDeletedEventData", + ) + + +__all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-apps-chat/google/apps/chat_v1/types/space_event.py b/packages/google-apps-chat/google/apps/chat_v1/types/space_event.py new file mode 100644 index 000000000000..96591e800225 --- /dev/null +++ b/packages/google-apps-chat/google/apps/chat_v1/types/space_event.py @@ -0,0 +1,518 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import annotations + +from typing import MutableMapping, MutableSequence + +from google.protobuf import timestamp_pb2 # type: ignore +import proto # type: ignore + +from google.apps.chat_v1.types import event_payload + +__protobuf__ = proto.module( + package="google.chat.v1", + manifest={ + "SpaceEvent", + "GetSpaceEventRequest", + "ListSpaceEventsRequest", + "ListSpaceEventsResponse", + }, +) + + +class SpaceEvent(proto.Message): + r"""An event that represents a change or activity in a Google Chat + space. To learn more, see `Work with events from Google + Chat `__. + + This message has `oneof`_ fields (mutually exclusive fields). + For each oneof, at most one member field can be set at the same time. + Setting any member of the oneof automatically clears all other + members. + + .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields + + Attributes: + name (str): + Resource name of the space event. + + Format: ``spaces/{space}/spaceEvents/{spaceEvent}`` + event_time (google.protobuf.timestamp_pb2.Timestamp): + Time when the event occurred. + event_type (str): + Type of space event. Each event type has a batch version, + which represents multiple instances of the event type that + occur in a short period of time. For ``spaceEvents.list()`` + requests, omit batch event types in your query filter. By + default, the server returns both event type and its batch + version. + + Supported event types for + `messages `__: + + :: + + * New message: `google.workspace.chat.message.v1.created` + * Updated message: `google.workspace.chat.message.v1.updated` + * Deleted message: `google.workspace.chat.message.v1.deleted` + * Multiple new messages: `google.workspace.chat.message.v1.batchCreated` + * Multiple updated messages: + `google.workspace.chat.message.v1.batchUpdated` + * Multiple deleted messages: + `google.workspace.chat.message.v1.batchDeleted` + + Supported event types for + `memberships `__: + + - New membership: + ``google.workspace.chat.membership.v1.created`` + - Updated membership: + ``google.workspace.chat.membership.v1.updated`` + - Deleted membership: + ``google.workspace.chat.membership.v1.deleted`` + - Multiple new memberships: + ``google.workspace.chat.membership.v1.batchCreated`` + - Multiple updated memberships: + ``google.workspace.chat.membership.v1.batchUpdated`` + - Multiple deleted memberships: + ``google.workspace.chat.membership.v1.batchDeleted`` + + Supported event types for + `reactions `__: + + - New reaction: + ``google.workspace.chat.reaction.v1.created`` + - Deleted reaction: + ``google.workspace.chat.reaction.v1.deleted`` + - Multiple new reactions: + ``google.workspace.chat.reaction.v1.batchCreated`` + - Multiple deleted reactions: + ``google.workspace.chat.reaction.v1.batchDeleted`` + + Supported event types about the + `space `__: + + - Updated space: ``google.workspace.chat.space.v1.updated`` + - Multiple space updates: + ``google.workspace.chat.space.v1.batchUpdated`` + message_created_event_data (google.apps.chat_v1.types.MessageCreatedEventData): + Event payload for a new message. + + Event type: ``google.workspace.chat.message.v1.created`` + + This field is a member of `oneof`_ ``payload``. + message_updated_event_data (google.apps.chat_v1.types.MessageUpdatedEventData): + Event payload for an updated message. + + Event type: ``google.workspace.chat.message.v1.updated`` + + This field is a member of `oneof`_ ``payload``. + message_deleted_event_data (google.apps.chat_v1.types.MessageDeletedEventData): + Event payload for a deleted message. + + Event type: ``google.workspace.chat.message.v1.deleted`` + + This field is a member of `oneof`_ ``payload``. + message_batch_created_event_data (google.apps.chat_v1.types.MessageBatchCreatedEventData): + Event payload for multiple new messages. + + Event type: + ``google.workspace.chat.message.v1.batchCreated`` + + This field is a member of `oneof`_ ``payload``. + message_batch_updated_event_data (google.apps.chat_v1.types.MessageBatchUpdatedEventData): + Event payload for multiple updated messages. + + Event type: + ``google.workspace.chat.message.v1.batchUpdated`` + + This field is a member of `oneof`_ ``payload``. + message_batch_deleted_event_data (google.apps.chat_v1.types.MessageBatchDeletedEventData): + Event payload for multiple deleted messages. + + Event type: + ``google.workspace.chat.message.v1.batchDeleted`` + + This field is a member of `oneof`_ ``payload``. + space_updated_event_data (google.apps.chat_v1.types.SpaceUpdatedEventData): + Event payload for a space update. + + Event type: ``google.workspace.chat.space.v1.updated`` + + This field is a member of `oneof`_ ``payload``. + space_batch_updated_event_data (google.apps.chat_v1.types.SpaceBatchUpdatedEventData): + Event payload for multiple updates to a space. + + Event type: ``google.workspace.chat.space.v1.batchUpdated`` + + This field is a member of `oneof`_ ``payload``. + membership_created_event_data (google.apps.chat_v1.types.MembershipCreatedEventData): + Event payload for a new membership. + + Event type: ``google.workspace.chat.membership.v1.created`` + + This field is a member of `oneof`_ ``payload``. + membership_updated_event_data (google.apps.chat_v1.types.MembershipUpdatedEventData): + Event payload for an updated membership. + + Event type: ``google.workspace.chat.membership.v1.updated`` + + This field is a member of `oneof`_ ``payload``. + membership_deleted_event_data (google.apps.chat_v1.types.MembershipDeletedEventData): + Event payload for a deleted membership. + + Event type: ``google.workspace.chat.membership.v1.deleted`` + + This field is a member of `oneof`_ ``payload``. + membership_batch_created_event_data (google.apps.chat_v1.types.MembershipBatchCreatedEventData): + Event payload for multiple new memberships. + + Event type: + ``google.workspace.chat.membership.v1.batchCreated`` + + This field is a member of `oneof`_ ``payload``. + membership_batch_updated_event_data (google.apps.chat_v1.types.MembershipBatchUpdatedEventData): + Event payload for multiple updated memberships. + + Event type: + ``google.workspace.chat.membership.v1.batchUpdated`` + + This field is a member of `oneof`_ ``payload``. + membership_batch_deleted_event_data (google.apps.chat_v1.types.MembershipBatchDeletedEventData): + Event payload for multiple deleted memberships. + + Event type: + ``google.workspace.chat.membership.v1.batchDeleted`` + + This field is a member of `oneof`_ ``payload``. + reaction_created_event_data (google.apps.chat_v1.types.ReactionCreatedEventData): + Event payload for a new reaction. + + Event type: ``google.workspace.chat.reaction.v1.created`` + + This field is a member of `oneof`_ ``payload``. + reaction_deleted_event_data (google.apps.chat_v1.types.ReactionDeletedEventData): + Event payload for a deleted reaction. + + Event type: ``google.workspace.chat.reaction.v1.deleted`` + + This field is a member of `oneof`_ ``payload``. + reaction_batch_created_event_data (google.apps.chat_v1.types.ReactionBatchCreatedEventData): + Event payload for multiple new reactions. + + Event type: + ``google.workspace.chat.reaction.v1.batchCreated`` + + This field is a member of `oneof`_ ``payload``. + reaction_batch_deleted_event_data (google.apps.chat_v1.types.ReactionBatchDeletedEventData): + Event payload for multiple deleted reactions. + + Event type: + ``google.workspace.chat.reaction.v1.batchDeleted`` + + This field is a member of `oneof`_ ``payload``. + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + event_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=3, + message=timestamp_pb2.Timestamp, + ) + event_type: str = proto.Field( + proto.STRING, + number=6, + ) + message_created_event_data: event_payload.MessageCreatedEventData = proto.Field( + proto.MESSAGE, + number=12, + oneof="payload", + message=event_payload.MessageCreatedEventData, + ) + message_updated_event_data: event_payload.MessageUpdatedEventData = proto.Field( + proto.MESSAGE, + number=13, + oneof="payload", + message=event_payload.MessageUpdatedEventData, + ) + message_deleted_event_data: event_payload.MessageDeletedEventData = proto.Field( + proto.MESSAGE, + number=14, + oneof="payload", + message=event_payload.MessageDeletedEventData, + ) + message_batch_created_event_data: event_payload.MessageBatchCreatedEventData = ( + proto.Field( + proto.MESSAGE, + number=26, + oneof="payload", + message=event_payload.MessageBatchCreatedEventData, + ) + ) + message_batch_updated_event_data: event_payload.MessageBatchUpdatedEventData = ( + proto.Field( + proto.MESSAGE, + number=27, + oneof="payload", + message=event_payload.MessageBatchUpdatedEventData, + ) + ) + message_batch_deleted_event_data: event_payload.MessageBatchDeletedEventData = ( + proto.Field( + proto.MESSAGE, + number=28, + oneof="payload", + message=event_payload.MessageBatchDeletedEventData, + ) + ) + space_updated_event_data: event_payload.SpaceUpdatedEventData = proto.Field( + proto.MESSAGE, + number=15, + oneof="payload", + message=event_payload.SpaceUpdatedEventData, + ) + space_batch_updated_event_data: event_payload.SpaceBatchUpdatedEventData = ( + proto.Field( + proto.MESSAGE, + number=29, + oneof="payload", + message=event_payload.SpaceBatchUpdatedEventData, + ) + ) + membership_created_event_data: event_payload.MembershipCreatedEventData = ( + proto.Field( + proto.MESSAGE, + number=17, + oneof="payload", + message=event_payload.MembershipCreatedEventData, + ) + ) + membership_updated_event_data: event_payload.MembershipUpdatedEventData = ( + proto.Field( + proto.MESSAGE, + number=18, + oneof="payload", + message=event_payload.MembershipUpdatedEventData, + ) + ) + membership_deleted_event_data: event_payload.MembershipDeletedEventData = ( + proto.Field( + proto.MESSAGE, + number=219, + oneof="payload", + message=event_payload.MembershipDeletedEventData, + ) + ) + membership_batch_created_event_data: event_payload.MembershipBatchCreatedEventData = proto.Field( + proto.MESSAGE, + number=31, + oneof="payload", + message=event_payload.MembershipBatchCreatedEventData, + ) + membership_batch_updated_event_data: event_payload.MembershipBatchUpdatedEventData = proto.Field( + proto.MESSAGE, + number=32, + oneof="payload", + message=event_payload.MembershipBatchUpdatedEventData, + ) + membership_batch_deleted_event_data: event_payload.MembershipBatchDeletedEventData = proto.Field( + proto.MESSAGE, + number=33, + oneof="payload", + message=event_payload.MembershipBatchDeletedEventData, + ) + reaction_created_event_data: event_payload.ReactionCreatedEventData = proto.Field( + proto.MESSAGE, + number=21, + oneof="payload", + message=event_payload.ReactionCreatedEventData, + ) + reaction_deleted_event_data: event_payload.ReactionDeletedEventData = proto.Field( + proto.MESSAGE, + number=22, + oneof="payload", + message=event_payload.ReactionDeletedEventData, + ) + reaction_batch_created_event_data: event_payload.ReactionBatchCreatedEventData = ( + proto.Field( + proto.MESSAGE, + number=34, + oneof="payload", + message=event_payload.ReactionBatchCreatedEventData, + ) + ) + reaction_batch_deleted_event_data: event_payload.ReactionBatchDeletedEventData = ( + proto.Field( + proto.MESSAGE, + number=35, + oneof="payload", + message=event_payload.ReactionBatchDeletedEventData, + ) + ) + + +class GetSpaceEventRequest(proto.Message): + r"""Request message for getting a space event. + + Attributes: + name (str): + Required. The resource name of the space event. + + Format: ``spaces/{space}/spaceEvents/{spaceEvent}`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class ListSpaceEventsRequest(proto.Message): + r"""Request message for listing space events. + + Attributes: + parent (str): + Required. Resource name of the `Google Chat + space `__ + where the events occurred. + + Format: ``spaces/{space}``. + page_size (int): + Optional. The maximum number of space events returned. The + service might return fewer than this value. + + Negative values return an ``INVALID_ARGUMENT`` error. + page_token (str): + A page token, received from a previous list + space events call. Provide this to retrieve the + subsequent page. + + When paginating, all other parameters provided + to list space events must match the call that + provided the page token. Passing different + values to the other parameters might lead to + unexpected results. + filter (str): + Required. A query filter. + + You must specify at least one event type (``event_type``) + using the has ``:`` operator. To filter by multiple event + types, use the ``OR`` operator. Omit batch event types in + your filter. The request automatically returns any related + batch events. For example, if you filter by new reactions + (``google.workspace.chat.reaction.v1.created``), the server + also returns batch new reactions events + (``google.workspace.chat.reaction.v1.batchCreated``). For a + list of supported event types, see the ```SpaceEvents`` + reference + documentation `__. + + Optionally, you can also filter by start time + (``start_time``) and end time (``end_time``): + + - ``start_time``: Exclusive timestamp from which to start + listing space events. You can list events that occurred + up to 28 days ago. If unspecified, lists space events + from the past 28 days. + - ``end_time``: Inclusive timestamp until which space + events are listed. If unspecified, lists events up to the + time of the request. + + To specify a start or end time, use the equals ``=`` + operator and format in + `RFC-3339 `__. To + filter by both ``start_time`` and ``end_time``, use the + ``AND`` operator. + + For example, the following queries are valid: + + :: + + start_time="2023-08-23T19:20:33+00:00" AND + end_time="2023-08-23T19:21:54+00:00" + + :: + + start_time="2023-08-23T19:20:33+00:00" AND + (event_types:"google.workspace.chat.space.v1.updated" OR + event_types:"google.workspace.chat.message.v1.created") + + The following queries are invalid: + + :: + + start_time="2023-08-23T19:20:33+00:00" OR + end_time="2023-08-23T19:21:54+00:00" + + :: + + event_types:"google.workspace.chat.space.v1.updated" AND + event_types:"google.workspace.chat.message.v1.created" + + Invalid queries are rejected by the server with an + ``INVALID_ARGUMENT`` error. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + page_size: int = proto.Field( + proto.INT32, + number=5, + ) + page_token: str = proto.Field( + proto.STRING, + number=6, + ) + filter: str = proto.Field( + proto.STRING, + number=8, + ) + + +class ListSpaceEventsResponse(proto.Message): + r"""Response message for listing space events. + + Attributes: + space_events (MutableSequence[google.apps.chat_v1.types.SpaceEvent]): + Results are returned in chronological order + (oldest event first). + next_page_token (str): + Continuation token used to fetch more events. + If this field is omitted, there are no + subsequent pages. + """ + + @property + def raw_page(self): + return self + + space_events: MutableSequence["SpaceEvent"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="SpaceEvent", + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +__all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_get_space_event_async.py b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_get_space_event_async.py new file mode 100644 index 000000000000..41d7f8879406 --- /dev/null +++ b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_get_space_event_async.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetSpaceEvent +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-apps-chat + + +# [START chat_v1_generated_ChatService_GetSpaceEvent_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.apps import chat_v1 + + +async def sample_get_space_event(): + # Create a client + client = chat_v1.ChatServiceAsyncClient() + + # Initialize request argument(s) + request = chat_v1.GetSpaceEventRequest( + name="name_value", + ) + + # Make the request + response = await client.get_space_event(request=request) + + # Handle the response + print(response) + +# [END chat_v1_generated_ChatService_GetSpaceEvent_async] diff --git a/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_get_space_event_sync.py b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_get_space_event_sync.py new file mode 100644 index 000000000000..b483aacec51e --- /dev/null +++ b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_get_space_event_sync.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetSpaceEvent +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-apps-chat + + +# [START chat_v1_generated_ChatService_GetSpaceEvent_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.apps import chat_v1 + + +def sample_get_space_event(): + # Create a client + client = chat_v1.ChatServiceClient() + + # Initialize request argument(s) + request = chat_v1.GetSpaceEventRequest( + name="name_value", + ) + + # Make the request + response = client.get_space_event(request=request) + + # Handle the response + print(response) + +# [END chat_v1_generated_ChatService_GetSpaceEvent_sync] diff --git a/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_list_space_events_async.py b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_list_space_events_async.py new file mode 100644 index 000000000000..f7e3fc2e7066 --- /dev/null +++ b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_list_space_events_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListSpaceEvents +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-apps-chat + + +# [START chat_v1_generated_ChatService_ListSpaceEvents_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.apps import chat_v1 + + +async def sample_list_space_events(): + # Create a client + client = chat_v1.ChatServiceAsyncClient() + + # Initialize request argument(s) + request = chat_v1.ListSpaceEventsRequest( + parent="parent_value", + filter="filter_value", + ) + + # Make the request + page_result = client.list_space_events(request=request) + + # Handle the response + async for response in page_result: + print(response) + +# [END chat_v1_generated_ChatService_ListSpaceEvents_async] diff --git a/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_list_space_events_sync.py b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_list_space_events_sync.py new file mode 100644 index 000000000000..d2ff333319c3 --- /dev/null +++ b/packages/google-apps-chat/samples/generated_samples/chat_v1_generated_chat_service_list_space_events_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListSpaceEvents +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-apps-chat + + +# [START chat_v1_generated_ChatService_ListSpaceEvents_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.apps import chat_v1 + + +def sample_list_space_events(): + # Create a client + client = chat_v1.ChatServiceClient() + + # Initialize request argument(s) + request = chat_v1.ListSpaceEventsRequest( + parent="parent_value", + filter="filter_value", + ) + + # Make the request + page_result = client.list_space_events(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END chat_v1_generated_ChatService_ListSpaceEvents_sync] diff --git a/packages/google-apps-chat/samples/generated_samples/snippet_metadata_google.chat.v1.json b/packages/google-apps-chat/samples/generated_samples/snippet_metadata_google.chat.v1.json index 2d78c485aac1..6e637d46d014 100644 --- a/packages/google-apps-chat/samples/generated_samples/snippet_metadata_google.chat.v1.json +++ b/packages/google-apps-chat/samples/generated_samples/snippet_metadata_google.chat.v1.json @@ -8,7 +8,7 @@ ], "language": "PYTHON", "name": "google-apps-chat", - "version": "0.1.8" + "version": "0.1.0" }, "snippets": [ { @@ -2102,6 +2102,167 @@ ], "title": "chat_v1_generated_chat_service_get_message_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.apps.chat_v1.ChatServiceAsyncClient", + "shortName": "ChatServiceAsyncClient" + }, + "fullName": "google.apps.chat_v1.ChatServiceAsyncClient.get_space_event", + "method": { + "fullName": "google.chat.v1.ChatService.GetSpaceEvent", + "service": { + "fullName": "google.chat.v1.ChatService", + "shortName": "ChatService" + }, + "shortName": "GetSpaceEvent" + }, + "parameters": [ + { + "name": "request", + "type": "google.apps.chat_v1.types.GetSpaceEventRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.apps.chat_v1.types.SpaceEvent", + "shortName": "get_space_event" + }, + "description": "Sample for GetSpaceEvent", + "file": "chat_v1_generated_chat_service_get_space_event_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "chat_v1_generated_ChatService_GetSpaceEvent_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "chat_v1_generated_chat_service_get_space_event_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.apps.chat_v1.ChatServiceClient", + "shortName": "ChatServiceClient" + }, + "fullName": "google.apps.chat_v1.ChatServiceClient.get_space_event", + "method": { + "fullName": "google.chat.v1.ChatService.GetSpaceEvent", + "service": { + "fullName": "google.chat.v1.ChatService", + "shortName": "ChatService" + }, + "shortName": "GetSpaceEvent" + }, + "parameters": [ + { + "name": "request", + "type": "google.apps.chat_v1.types.GetSpaceEventRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.apps.chat_v1.types.SpaceEvent", + "shortName": "get_space_event" + }, + "description": "Sample for GetSpaceEvent", + "file": "chat_v1_generated_chat_service_get_space_event_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "chat_v1_generated_ChatService_GetSpaceEvent_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "chat_v1_generated_chat_service_get_space_event_sync.py" + }, { "canonical": true, "clientMethod": { @@ -3068,6 +3229,175 @@ ], "title": "chat_v1_generated_chat_service_list_reactions_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.apps.chat_v1.ChatServiceAsyncClient", + "shortName": "ChatServiceAsyncClient" + }, + "fullName": "google.apps.chat_v1.ChatServiceAsyncClient.list_space_events", + "method": { + "fullName": "google.chat.v1.ChatService.ListSpaceEvents", + "service": { + "fullName": "google.chat.v1.ChatService", + "shortName": "ChatService" + }, + "shortName": "ListSpaceEvents" + }, + "parameters": [ + { + "name": "request", + "type": "google.apps.chat_v1.types.ListSpaceEventsRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "filter", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.apps.chat_v1.services.chat_service.pagers.ListSpaceEventsAsyncPager", + "shortName": "list_space_events" + }, + "description": "Sample for ListSpaceEvents", + "file": "chat_v1_generated_chat_service_list_space_events_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "chat_v1_generated_ChatService_ListSpaceEvents_async", + "segments": [ + { + "end": 53, + "start": 27, + "type": "FULL" + }, + { + "end": 53, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 54, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "chat_v1_generated_chat_service_list_space_events_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.apps.chat_v1.ChatServiceClient", + "shortName": "ChatServiceClient" + }, + "fullName": "google.apps.chat_v1.ChatServiceClient.list_space_events", + "method": { + "fullName": "google.chat.v1.ChatService.ListSpaceEvents", + "service": { + "fullName": "google.chat.v1.ChatService", + "shortName": "ChatService" + }, + "shortName": "ListSpaceEvents" + }, + "parameters": [ + { + "name": "request", + "type": "google.apps.chat_v1.types.ListSpaceEventsRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "filter", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.apps.chat_v1.services.chat_service.pagers.ListSpaceEventsPager", + "shortName": "list_space_events" + }, + "description": "Sample for ListSpaceEvents", + "file": "chat_v1_generated_chat_service_list_space_events_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "chat_v1_generated_ChatService_ListSpaceEvents_sync", + "segments": [ + { + "end": 53, + "start": 27, + "type": "FULL" + }, + { + "end": 53, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 54, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "chat_v1_generated_chat_service_list_space_events_sync.py" + }, { "canonical": true, "clientMethod": { diff --git a/packages/google-apps-chat/scripts/fixup_chat_v1_keywords.py b/packages/google-apps-chat/scripts/fixup_chat_v1_keywords.py index ba4a80893a22..6dfa6d4d93f8 100644 --- a/packages/google-apps-chat/scripts/fixup_chat_v1_keywords.py +++ b/packages/google-apps-chat/scripts/fixup_chat_v1_keywords.py @@ -53,11 +53,13 @@ class chatCallTransformer(cst.CSTTransformer): 'get_membership': ('name', ), 'get_message': ('name', ), 'get_space': ('name', ), + 'get_space_event': ('name', ), 'get_space_read_state': ('name', ), 'get_thread_read_state': ('name', ), 'list_memberships': ('parent', 'page_size', 'page_token', 'filter', 'show_groups', 'show_invited', ), 'list_messages': ('parent', 'page_size', 'page_token', 'filter', 'order_by', 'show_deleted', ), 'list_reactions': ('parent', 'page_size', 'page_token', 'filter', ), + 'list_space_events': ('parent', 'filter', 'page_size', 'page_token', ), 'list_spaces': ('page_size', 'page_token', 'filter', ), 'set_up_space': ('space', 'request_id', 'memberships', ), 'update_membership': ('membership', 'update_mask', ), diff --git a/packages/google-apps-chat/tests/unit/gapic/chat_v1/test_chat_service.py b/packages/google-apps-chat/tests/unit/gapic/chat_v1/test_chat_service.py index d6a83e2a9d57..f8dc50309302 100644 --- a/packages/google-apps-chat/tests/unit/gapic/chat_v1/test_chat_service.py +++ b/packages/google-apps-chat/tests/unit/gapic/chat_v1/test_chat_service.py @@ -60,6 +60,7 @@ attachment, contextual_addon, deletion_metadata, + event_payload, group, history_state, matched_url, @@ -74,6 +75,7 @@ from google.apps.chat_v1.types import slash_command from google.apps.chat_v1.types import space from google.apps.chat_v1.types import space as gc_space +from google.apps.chat_v1.types import space_event from google.apps.chat_v1.types import space_read_state from google.apps.chat_v1.types import space_read_state as gc_space_read_state @@ -11341,489 +11343,95 @@ async def test_get_thread_read_state_flattened_error_async(): @pytest.mark.parametrize( "request_type", [ - gc_message.CreateMessageRequest, + space_event.GetSpaceEventRequest, dict, ], ) -def test_create_message_rest(request_type): +def test_get_space_event(request_type, transport: str = "grpc"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request_init["message"] = { - "name": "name_value", - "sender": { - "name": "name_value", - "display_name": "display_name_value", - "domain_id": "domain_id_value", - "type_": 1, - "is_anonymous": True, - }, - "create_time": {"seconds": 751, "nanos": 543}, - "last_update_time": {}, - "delete_time": {}, - "text": "text_value", - "formatted_text": "formatted_text_value", - "cards": [ - { - "header": { - "title": "title_value", - "subtitle": "subtitle_value", - "image_style": 1, - "image_url": "image_url_value", - }, - "sections": [ - { - "header": "header_value", - "widgets": [ - { - "text_paragraph": {"text": "text_value"}, - "image": { - "image_url": "image_url_value", - "on_click": { - "action": { - "action_method_name": "action_method_name_value", - "parameters": [ - { - "key": "key_value", - "value": "value_value", - } - ], - }, - "open_link": {"url": "url_value"}, - }, - "aspect_ratio": 0.1278, - }, - "key_value": { - "icon": 1, - "icon_url": "icon_url_value", - "top_label": "top_label_value", - "content": "content_value", - "content_multiline": True, - "bottom_label": "bottom_label_value", - "on_click": {}, - "button": { - "text_button": { - "text": "text_value", - "on_click": {}, - }, - "image_button": { - "icon": 1, - "icon_url": "icon_url_value", - "on_click": {}, - "name": "name_value", - }, - }, - }, - "buttons": {}, - } - ], - } - ], - "card_actions": [ - {"action_label": "action_label_value", "on_click": {}} - ], - "name": "name_value", - } - ], - "cards_v2": [ - { - "card_id": "card_id_value", - "card": { - "header": { - "title": "title_value", - "subtitle": "subtitle_value", - "image_type": 1, - "image_url": "image_url_value", - "image_alt_text": "image_alt_text_value", - }, - "sections": [ - { - "header": "header_value", - "widgets": [ - { - "text_paragraph": {"text": "text_value"}, - "image": { - "image_url": "image_url_value", - "on_click": { - "action": { - "function": "function_value", - "parameters": [ - { - "key": "key_value", - "value": "value_value", - } - ], - "load_indicator": 1, - "persist_values": True, - "interaction": 1, - }, - "open_link": { - "url": "url_value", - "open_as": 1, - "on_close": 1, - }, - "open_dynamic_link_action": {}, - "card": {}, - }, - "alt_text": "alt_text_value", - }, - "decorated_text": { - "icon": { - "known_icon": "known_icon_value", - "icon_url": "icon_url_value", - "material_icon": { - "name": "name_value", - "fill": True, - "weight": 648, - "grade": 515, - }, - "alt_text": "alt_text_value", - "image_type": 1, - }, - "start_icon": {}, - "top_label": "top_label_value", - "text": "text_value", - "wrap_text": True, - "bottom_label": "bottom_label_value", - "on_click": {}, - "button": { - "text": "text_value", - "icon": {}, - "color": { - "red": 0.315, - "green": 0.529, - "blue": 0.424, - "alpha": {"value": 0.541}, - }, - "on_click": {}, - "disabled": True, - "alt_text": "alt_text_value", - }, - "switch_control": { - "name": "name_value", - "value": "value_value", - "selected": True, - "on_change_action": {}, - "control_type": 1, - }, - "end_icon": {}, - }, - "button_list": {"buttons": {}}, - "text_input": { - "name": "name_value", - "label": "label_value", - "hint_text": "hint_text_value", - "value": "value_value", - "type_": 1, - "on_change_action": {}, - "initial_suggestions": { - "items": [{"text": "text_value"}] - }, - "auto_complete_action": {}, - "placeholder_text": "placeholder_text_value", - }, - "selection_input": { - "name": "name_value", - "label": "label_value", - "type_": 1, - "items": [ - { - "text": "text_value", - "value": "value_value", - "selected": True, - "start_icon_uri": "start_icon_uri_value", - "bottom_text": "bottom_text_value", - } - ], - "on_change_action": {}, - "multi_select_max_selected_items": 3288, - "multi_select_min_query_length": 3107, - "external_data_source": {}, - "platform_data_source": { - "common_data_source": 1 - }, - }, - "date_time_picker": { - "name": "name_value", - "label": "label_value", - "type_": 1, - "value_ms_epoch": 1482, - "timezone_offset_date": 2126, - "on_change_action": {}, - }, - "divider": {}, - "grid": { - "title": "title_value", - "items": [ - { - "id": "id_value", - "image": { - "image_uri": "image_uri_value", - "alt_text": "alt_text_value", - "crop_style": { - "type_": 1, - "aspect_ratio": 0.1278, - }, - "border_style": { - "type_": 1, - "stroke_color": {}, - "corner_radius": 1392, - }, - }, - "title": "title_value", - "subtitle": "subtitle_value", - "layout": 1, - } - ], - "border_style": {}, - "column_count": 1302, - "on_click": {}, - }, - "columns": { - "column_items": [ - { - "horizontal_size_style": 1, - "horizontal_alignment": 1, - "vertical_alignment": 1, - "widgets": [ - { - "text_paragraph": {}, - "image": {}, - "decorated_text": {}, - "button_list": {}, - "text_input": {}, - "selection_input": {}, - "date_time_picker": {}, - } - ], - } - ] - }, - "horizontal_alignment": 1, - } - ], - "collapsible": True, - "uncollapsible_widgets_count": 2891, - } - ], - "section_divider_style": 1, - "card_actions": [ - {"action_label": "action_label_value", "on_click": {}} - ], - "name": "name_value", - "fixed_footer": {"primary_button": {}, "secondary_button": {}}, - "display_style": 1, - "peek_card_header": {}, - }, - } - ], - "annotations": [ - { - "type_": 1, - "start_index": 1189, - "length": 642, - "user_mention": {"user": {}, "type_": 1}, - "slash_command": { - "bot": {}, - "type_": 1, - "command_name": "command_name_value", - "command_id": 1035, - "triggers_dialog": True, - }, - "rich_link_metadata": { - "uri": "uri_value", - "rich_link_type": 1, - "drive_link_data": { - "drive_data_ref": {"drive_file_id": "drive_file_id_value"}, - "mime_type": "mime_type_value", - }, - }, - } - ], - "thread": {"name": "name_value", "thread_key": "thread_key_value"}, - "space": { - "name": "name_value", - "type_": 1, - "space_type": 1, - "single_user_bot_dm": True, - "threaded": True, - "display_name": "display_name_value", - "external_user_allowed": True, - "space_threading_state": 2, - "space_details": { - "description": "description_value", - "guidelines": "guidelines_value", - }, - "space_history_state": 1, - "import_mode": True, - "create_time": {}, - "admin_installed": True, - "access_settings": {"access_state": 1, "audience": "audience_value"}, - "space_uri": "space_uri_value", - }, - "fallback_text": "fallback_text_value", - "action_response": { - "type_": 1, - "url": "url_value", - "dialog_action": { - "dialog": {"body": {}}, - "action_status": { - "status_code": 1, - "user_facing_message": "user_facing_message_value", - }, - }, - "updated_widget": {"suggestions": {"items": {}}, "widget": "widget_value"}, - }, - "argument_text": "argument_text_value", - "slash_command": {"command_id": 1035}, - "attachment": [ - { - "name": "name_value", - "content_name": "content_name_value", - "content_type": "content_type_value", - "attachment_data_ref": { - "resource_name": "resource_name_value", - "attachment_upload_token": "attachment_upload_token_value", - }, - "drive_data_ref": {}, - "thumbnail_uri": "thumbnail_uri_value", - "download_uri": "download_uri_value", - "source": 1, - } - ], - "matched_url": {"url": "url_value"}, - "thread_reply": True, - "client_assigned_message_id": "client_assigned_message_id_value", - "emoji_reaction_summaries": [ - { - "emoji": { - "unicode": "unicode_value", - "custom_emoji": {"uid": "uid_value"}, - }, - "reaction_count": 1501, - } - ], - "private_message_viewer": {}, - "deletion_metadata": {"deletion_type": 1}, - "quoted_message_metadata": {"name": "name_value", "last_update_time": {}}, - "attached_gifs": [{"uri": "uri_value"}], - "accessory_widgets": [{"button_list": {}}], - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() - # Determine if the message type is proto-plus or protobuf - test_field = gc_message.CreateMessageRequest.meta.fields["message"] + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = space_event.SpaceEvent( + name="name_value", + event_type="event_type_value", + ) + response = client.get_space_event(request) - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = space_event.GetSpaceEventRequest() + assert args[0] == request - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + # Establish that the response is the type that we expect. + assert isinstance(response, space_event.SpaceEvent) + assert response.name == "name_value" + assert response.event_type == "event_type_value" - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] +def test_get_space_event_empty_call(): + # This test is a coverage failsafe to make sure that totally empty calls, + # i.e. request == None and no flattened fields passed, work. + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) - subfields_not_in_runtime = [] + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_space_event() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == space_event.GetSpaceEventRequest() - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["message"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) +def test_get_space_event_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["message"][field])): - del request_init["message"][field][i][subfield] - else: - del request_init["message"][field][subfield] - request = request_type(**request_init) + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = space_event.GetSpaceEventRequest( + name="name_value", + ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = gc_message.Message( + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_space_event(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == space_event.GetSpaceEventRequest( name="name_value", - text="text_value", - formatted_text="formatted_text_value", - fallback_text="fallback_text_value", - argument_text="argument_text_value", - thread_reply=True, - client_assigned_message_id="client_assigned_message_id_value", ) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gc_message.Message.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - response = client.create_message(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, gc_message.Message) - assert response.name == "name_value" - assert response.text == "text_value" - assert response.formatted_text == "formatted_text_value" - assert response.fallback_text == "fallback_text_value" - assert response.argument_text == "argument_text_value" - assert response.thread_reply is True - assert response.client_assigned_message_id == "client_assigned_message_id_value" - -def test_create_message_rest_use_cached_wrapped_rpc(): +def test_get_space_event_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -11831,327 +11439,376 @@ def test_create_message_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_message in client._transport._wrapped_methods + assert client._transport.get_space_event in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.create_message] = mock_rpc - + client._transport._wrapped_methods[client._transport.get_space_event] = mock_rpc request = {} - client.create_message(request) + client.get_space_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_message(request) + client.get_space_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_message_rest_required_fields( - request_type=gc_message.CreateMessageRequest, -): - transport_class = transports.ChatServiceRestTransport - - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) +@pytest.mark.asyncio +async def test_get_space_event_empty_call_async(): + # This test is a coverage failsafe to make sure that totally empty calls, + # i.e. request == None and no flattened fields passed, work. + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc_asyncio", ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_message._get_unset_required_fields(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() - ).create_message._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "message_id", - "message_reply_option", - "request_id", - "thread_key", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.SpaceEvent( + name="name_value", + event_type="event_type_value", + ) ) - ) - jsonified_request.update(unset_fields) + response = await client.get_space_event() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == space_event.GetSpaceEventRequest() - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) +@pytest.mark.asyncio +async def test_get_space_event_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - # Designate an appropriate value for the returned response. - return_value = gc_message.Message() - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "post", - "query_params": pb_request, - } - transcode_result["body"] = pb_request - transcode.return_value = transcode_result + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - response_value = Response() - response_value.status_code = 200 + # Ensure method has been cached + assert ( + client._client._transport.get_space_event + in client._client._transport._wrapped_methods + ) - # Convert return value to protobuf type - return_value = gc_message.Message.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + # Replace cached wrapped function with mock + mock_object = mock.AsyncMock() + client._client._transport._wrapped_methods[ + client._client._transport.get_space_event + ] = mock_object - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value + request = {} + await client.get_space_event(request) - response = client.create_message(request) + # Establish that the underlying gRPC stub method was called. + assert mock_object.call_count == 1 - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + await client.get_space_event(request) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_object.call_count == 2 -def test_create_message_rest_unset_required_fields(): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.create_message._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "messageId", - "messageReplyOption", - "requestId", - "threadKey", - ) - ) - & set( - ( - "parent", - "message", - ) - ) +@pytest.mark.asyncio +async def test_get_space_event_async( + transport: str = "grpc_asyncio", request_type=space_event.GetSpaceEventRequest +): + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_message_rest_interceptors(null_interceptor): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.ChatServiceRestInterceptor(), - ) - client = ChatServiceClient(transport=transport) - with mock.patch.object( - type(client.transport._session), "request" - ) as req, mock.patch.object( - path_template, "transcode" - ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_create_message" - ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_create_message" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - pb_message = gc_message.CreateMessageRequest.pb( - gc_message.CreateMessageRequest() + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.SpaceEvent( + name="name_value", + event_type="event_type_value", + ) ) - transcode.return_value = { - "method": "post", - "uri": "my_uri", - "body": pb_message, - "query_params": pb_message, - } + response = await client.get_space_event(request) - req.return_value = Response() - req.return_value.status_code = 200 - req.return_value.request = PreparedRequest() - req.return_value._content = gc_message.Message.to_json(gc_message.Message()) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = space_event.GetSpaceEventRequest() + assert args[0] == request - request = gc_message.CreateMessageRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = gc_message.Message() + # Establish that the response is the type that we expect. + assert isinstance(response, space_event.SpaceEvent) + assert response.name == "name_value" + assert response.event_type == "event_type_value" - client.create_message( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - pre.assert_called_once() - post.assert_called_once() +@pytest.mark.asyncio +async def test_get_space_event_async_from_dict(): + await test_get_space_event_async(request_type=dict) -def test_create_message_rest_bad_request( - transport: str = "rest", request_type=gc_message.CreateMessageRequest -): +def test_get_space_event_field_headers(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request = request_type(**request_init) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = space_event.GetSpaceEventRequest() - # Mock the http request call within the method and fake a BadRequest error. - with mock.patch.object(Session, "request") as req, pytest.raises( - core_exceptions.BadRequest - ): - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 400 - response_value.request = Request() - req.return_value = response_value - client.create_message(request) + request.name = "name_value" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + call.return_value = space_event.SpaceEvent() + client.get_space_event(request) -def test_create_message_rest_flattened(): - client = ChatServiceClient( + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_space_event_field_headers_async(): + client = ChatServiceAsyncClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = gc_message.Message() + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = space_event.GetSpaceEventRequest() - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "spaces/sample1"} + request.name = "name_value" - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - message=gc_message.Message(name="name_value"), - message_id="message_id_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.SpaceEvent() ) - mock_args.update(sample_request) + await client.get_space_event(request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gc_message.Message.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request - client.create_message(**mock_args) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_get_space_event_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = space_event.SpaceEvent() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_space_event( + name="name_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=spaces/*}/messages" % client.transport._host, args[1] - ) + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val -def test_create_message_rest_flattened_error(transport: str = "rest"): +def test_get_space_event_flattened_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_message( - gc_message.CreateMessageRequest(), - parent="parent_value", - message=gc_message.Message(name="name_value"), - message_id="message_id_value", + client.get_space_event( + space_event.GetSpaceEventRequest(), + name="name_value", ) -def test_create_message_rest_error(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" +@pytest.mark.asyncio +async def test_get_space_event_flattened_async(): + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_space_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = space_event.SpaceEvent() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.SpaceEvent() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_space_event( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_get_space_event_flattened_error_async(): + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), ) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_space_event( + space_event.GetSpaceEventRequest(), + name="name_value", + ) + @pytest.mark.parametrize( "request_type", [ - message.ListMessagesRequest, + space_event.ListSpaceEventsRequest, dict, ], ) -def test_list_messages_rest(request_type): +def test_list_space_events(request_type, transport: str = "grpc"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request = request_type(**request_init) + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = message.ListMessagesResponse( + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = space_event.ListSpaceEventsResponse( next_page_token="next_page_token_value", ) + response = client.list_space_events(request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = message.ListMessagesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - response = client.list_messages(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = space_event.ListSpaceEventsRequest() + assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListMessagesPager) + assert isinstance(response, pagers.ListSpaceEventsPager) assert response.next_page_token == "next_page_token_value" -def test_list_messages_rest_use_cached_wrapped_rpc(): +def test_list_space_events_empty_call(): + # This test is a coverage failsafe to make sure that totally empty calls, + # i.e. request == None and no flattened fields passed, work. + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_space_events() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == space_event.ListSpaceEventsRequest() + + +def test_list_space_events_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = space_event.ListSpaceEventsRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_space_events(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == space_event.ListSpaceEventsRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + +def test_list_space_events_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -12159,675 +11816,1985 @@ def test_list_messages_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_messages in client._transport._wrapped_methods + assert client._transport.list_space_events in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.list_messages] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.list_space_events + ] = mock_rpc request = {} - client.list_messages(request) + client.list_space_events(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_messages(request) + client.list_space_events(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_list_messages_rest_required_fields(request_type=message.ListMessagesRequest): - transport_class = transports.ChatServiceRestTransport - - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) +@pytest.mark.asyncio +async def test_list_space_events_empty_call_async(): + # This test is a coverage failsafe to make sure that totally empty calls, + # i.e. request == None and no flattened fields passed, work. + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc_asyncio", ) - # verify fields with default values are dropped + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.ListSpaceEventsResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_space_events() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == space_event.ListSpaceEventsRequest() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_messages._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with default values are now present +@pytest.mark.asyncio +async def test_list_space_events_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - jsonified_request["parent"] = "parent_value" + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_messages._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", - "show_deleted", + # Ensure method has been cached + assert ( + client._client._transport.list_space_events + in client._client._transport._wrapped_methods ) - ) - 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" + # Replace cached wrapped function with mock + mock_object = mock.AsyncMock() + client._client._transport._wrapped_methods[ + client._client._transport.list_space_events + ] = mock_object - client = ChatServiceClient( + request = {} + await client.list_space_events(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_object.call_count == 1 + + await client.list_space_events(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_object.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_space_events_async( + transport: str = "grpc_asyncio", request_type=space_event.ListSpaceEventsRequest +): + client = ChatServiceAsyncClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = message.ListMessagesResponse() - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "get", - "query_params": pb_request, - } - transcode.return_value = transcode_result + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() - response_value = Response() - response_value.status_code = 200 + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.ListSpaceEventsResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_space_events(request) - # Convert return value to protobuf type - return_value = message.ListMessagesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = space_event.ListSpaceEventsRequest() + assert args[0] == request - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListSpaceEventsAsyncPager) + assert response.next_page_token == "next_page_token_value" - response = client.list_messages(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params +@pytest.mark.asyncio +async def test_list_space_events_async_from_dict(): + await test_list_space_events_async(request_type=dict) -def test_list_messages_rest_unset_required_fields(): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_list_space_events_field_headers(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.list_messages._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "orderBy", - "pageSize", - "pageToken", - "showDeleted", - ) - ) - & set(("parent",)) - ) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = space_event.ListSpaceEventsRequest() + + request.parent = "parent_value" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + call.return_value = space_event.ListSpaceEventsResponse() + client.list_space_events(request) -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_messages_rest_interceptors(null_interceptor): - transport = transports.ChatServiceRestTransport( + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_space_events_field_headers_async(): + client = ChatServiceAsyncClient( credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.ChatServiceRestInterceptor(), ) - client = ChatServiceClient(transport=transport) - with mock.patch.object( - type(client.transport._session), "request" - ) as req, mock.patch.object( - path_template, "transcode" - ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_list_messages" - ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_list_messages" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - pb_message = message.ListMessagesRequest.pb(message.ListMessagesRequest()) - transcode.return_value = { - "method": "post", - "uri": "my_uri", - "body": pb_message, - "query_params": pb_message, - } - req.return_value = Response() - req.return_value.status_code = 200 - req.return_value.request = PreparedRequest() - req.return_value._content = message.ListMessagesResponse.to_json( - message.ListMessagesResponse() - ) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = space_event.ListSpaceEventsRequest() - request = message.ListMessagesRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = message.ListMessagesResponse() + request.parent = "parent_value" - client.list_messages( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.ListSpaceEventsResponse() ) + await client.list_space_events(request) - pre.assert_called_once() - post.assert_called_once() + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] -def test_list_messages_rest_bad_request( - transport: str = "rest", request_type=message.ListMessagesRequest -): +def test_list_space_events_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request = request_type(**request_init) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = space_event.ListSpaceEventsResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_space_events( + parent="parent_value", + filter="filter_value", + ) - # Mock the http request call within the method and fake a BadRequest error. - with mock.patch.object(Session, "request") as req, pytest.raises( - core_exceptions.BadRequest - ): - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 400 - response_value.request = Request() - req.return_value = response_value - client.list_messages(request) + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].filter + mock_val = "filter_value" + assert arg == mock_val -def test_list_messages_rest_flattened(): +def test_list_space_events_flattened_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = message.ListMessagesResponse() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "spaces/sample1"} - - # get truthy value for each flattened field - mock_args = dict( + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_space_events( + space_event.ListSpaceEventsRequest(), parent="parent_value", + filter="filter_value", ) - mock_args.update(sample_request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = message.ListMessagesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - client.list_messages(**mock_args) +@pytest.mark.asyncio +async def test_list_space_events_flattened_async(): + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = space_event.ListSpaceEventsResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + space_event.ListSpaceEventsResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_space_events( + parent="parent_value", + filter="filter_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=spaces/*}/messages" % client.transport._host, args[1] - ) + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].filter + mock_val = "filter_value" + assert arg == mock_val -def test_list_messages_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( +@pytest.mark.asyncio +async def test_list_space_events_flattened_error_async(): + client = ChatServiceAsyncClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_messages( - message.ListMessagesRequest(), + await client.list_space_events( + space_event.ListSpaceEventsRequest(), parent="parent_value", + filter="filter_value", ) -def test_list_messages_rest_pager(transport: str = "rest"): +def test_list_space_events_pager(transport_name: str = "grpc"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport=transport_name, ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - message.ListMessagesResponse( - messages=[ - message.Message(), - message.Message(), - message.Message(), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + space_event.SpaceEvent(), ], next_page_token="abc", ), - message.ListMessagesResponse( - messages=[], + space_event.ListSpaceEventsResponse( + space_events=[], next_page_token="def", ), - message.ListMessagesResponse( - messages=[ - message.Message(), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), ], next_page_token="ghi", ), - message.ListMessagesResponse( - messages=[ - message.Message(), - message.Message(), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), ], ), + RuntimeError, ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple(message.ListMessagesResponse.to_json(x) for x in response) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - sample_request = {"parent": "spaces/sample1"} + expected_metadata = () + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_space_events(request={}) - pager = client.list_messages(request=sample_request) + assert pager._metadata == expected_metadata results = list(pager) assert len(results) == 6 - assert all(isinstance(i, message.Message) for i in results) - - pages = list(client.list_messages(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token + assert all(isinstance(i, space_event.SpaceEvent) for i in results) -@pytest.mark.parametrize( - "request_type", - [ - membership.ListMembershipsRequest, - dict, - ], -) -def test_list_memberships_rest(request_type): +def test_list_space_events_pages(transport_name: str = "grpc"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport_name, ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request = request_type(**request_init) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = membership.ListMembershipsResponse( - next_page_token="next_page_token_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + next_page_token="abc", + ), + space_event.ListSpaceEventsResponse( + space_events=[], + next_page_token="def", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + ], + next_page_token="ghi", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + ), + RuntimeError, ) + pages = list(client.list_space_events(request={}).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = membership.ListMembershipsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - response = client.list_memberships(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListMembershipsPager) - assert response.next_page_token == "next_page_token_value" +@pytest.mark.asyncio +async def test_list_space_events_async_pager(): + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) -def test_list_memberships_rest_use_cached_wrapped_rpc(): - # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, - # instead of constructing them on each call - with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + next_page_token="abc", + ), + space_event.ListSpaceEventsResponse( + space_events=[], + next_page_token="def", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + ], + next_page_token="ghi", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + ), + RuntimeError, ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() - - # Ensure method has been cached - assert client._transport.list_memberships in client._transport._wrapped_methods - - # Replace cached wrapped function with mock - mock_rpc = mock.Mock() - mock_rpc.return_value.name = ( - "foo" # operation_request.operation in compute client(s) expect a string. + async_pager = await client.list_space_events( + request={}, ) - client._transport._wrapped_methods[ - client._transport.list_memberships - ] = mock_rpc - - request = {} - client.list_memberships(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.list_memberships(request) - - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + assert async_pager.next_page_token == "abc" + responses = [] + async for response in async_pager: # pragma: no branch + responses.append(response) + assert len(responses) == 6 + assert all(isinstance(i, space_event.SpaceEvent) for i in responses) -def test_list_memberships_rest_required_fields( - request_type=membership.ListMembershipsRequest, -): - transport_class = transports.ChatServiceRestTransport - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) +@pytest.mark.asyncio +async def test_list_space_events_async_pages(): + client = ChatServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_memberships._get_unset_required_fields(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_memberships._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", - "show_groups", - "show_invited", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_space_events), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + next_page_token="abc", + ), + space_event.ListSpaceEventsResponse( + space_events=[], + next_page_token="def", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + ], + next_page_token="ghi", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + ), + RuntimeError, ) - ) - jsonified_request.update(unset_fields) + pages = [] + # Workaround issue in python 3.9 related to code coverage by adding `# pragma: no branch` + # See https://github.com/googleapis/gapic-generator-python/pull/1174#issuecomment-1025132372 + async for page_ in ( # pragma: no branch + await client.list_space_events(request={}) + ).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" +@pytest.mark.parametrize( + "request_type", + [ + gc_message.CreateMessageRequest, + dict, + ], +) +def test_create_message_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = membership.ListMembershipsResponse() - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "get", - "query_params": pb_request, - } - transcode.return_value = transcode_result - - response_value = Response() - response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = membership.ListMembershipsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - response = client.list_memberships(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_list_memberships_rest_unset_required_fields(): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.list_memberships._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "pageSize", - "pageToken", - "showGroups", - "showInvited", - ) - ) - & set(("parent",)) - ) - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_memberships_rest_interceptors(null_interceptor): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.ChatServiceRestInterceptor(), - ) - client = ChatServiceClient(transport=transport) - with mock.patch.object( - type(client.transport._session), "request" - ) as req, mock.patch.object( - path_template, "transcode" - ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_list_memberships" - ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_list_memberships" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - pb_message = membership.ListMembershipsRequest.pb( - membership.ListMembershipsRequest() - ) - transcode.return_value = { - "method": "post", - "uri": "my_uri", - "body": pb_message, - "query_params": pb_message, - } - - req.return_value = Response() - req.return_value.status_code = 200 - req.return_value.request = PreparedRequest() - req.return_value._content = membership.ListMembershipsResponse.to_json( - membership.ListMembershipsResponse() - ) - - request = membership.ListMembershipsRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = membership.ListMembershipsResponse() - - client.list_memberships( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - post.assert_called_once() - - -def test_list_memberships_rest_bad_request( - transport: str = "rest", request_type=membership.ListMembershipsRequest -): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) # send a request that will satisfy transcoding request_init = {"parent": "spaces/sample1"} - request = request_type(**request_init) - - # Mock the http request call within the method and fake a BadRequest error. - with mock.patch.object(Session, "request") as req, pytest.raises( - core_exceptions.BadRequest - ): - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 400 - response_value.request = Request() - req.return_value = response_value - client.list_memberships(request) - - -def test_list_memberships_rest_flattened(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = membership.ListMembershipsResponse() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "spaces/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = membership.ListMembershipsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.list_memberships(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=spaces/*}/members" % client.transport._host, args[1] - ) - - -def test_list_memberships_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.list_memberships( - membership.ListMembershipsRequest(), - parent="parent_value", - ) - - -def test_list_memberships_rest_pager(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - membership.ListMembershipsResponse( - memberships=[ - membership.Membership(), - membership.Membership(), - membership.Membership(), + request_init["message"] = { + "name": "name_value", + "sender": { + "name": "name_value", + "display_name": "display_name_value", + "domain_id": "domain_id_value", + "type_": 1, + "is_anonymous": True, + }, + "create_time": {"seconds": 751, "nanos": 543}, + "last_update_time": {}, + "delete_time": {}, + "text": "text_value", + "formatted_text": "formatted_text_value", + "cards": [ + { + "header": { + "title": "title_value", + "subtitle": "subtitle_value", + "image_style": 1, + "image_url": "image_url_value", + }, + "sections": [ + { + "header": "header_value", + "widgets": [ + { + "text_paragraph": {"text": "text_value"}, + "image": { + "image_url": "image_url_value", + "on_click": { + "action": { + "action_method_name": "action_method_name_value", + "parameters": [ + { + "key": "key_value", + "value": "value_value", + } + ], + }, + "open_link": {"url": "url_value"}, + }, + "aspect_ratio": 0.1278, + }, + "key_value": { + "icon": 1, + "icon_url": "icon_url_value", + "top_label": "top_label_value", + "content": "content_value", + "content_multiline": True, + "bottom_label": "bottom_label_value", + "on_click": {}, + "button": { + "text_button": { + "text": "text_value", + "on_click": {}, + }, + "image_button": { + "icon": 1, + "icon_url": "icon_url_value", + "on_click": {}, + "name": "name_value", + }, + }, + }, + "buttons": {}, + } + ], + } ], - next_page_token="abc", - ), - membership.ListMembershipsResponse( - memberships=[], - next_page_token="def", - ), - membership.ListMembershipsResponse( - memberships=[ - membership.Membership(), + "card_actions": [ + {"action_label": "action_label_value", "on_click": {}} ], - next_page_token="ghi", - ), - membership.ListMembershipsResponse( - memberships=[ + "name": "name_value", + } + ], + "cards_v2": [ + { + "card_id": "card_id_value", + "card": { + "header": { + "title": "title_value", + "subtitle": "subtitle_value", + "image_type": 1, + "image_url": "image_url_value", + "image_alt_text": "image_alt_text_value", + }, + "sections": [ + { + "header": "header_value", + "widgets": [ + { + "text_paragraph": {"text": "text_value"}, + "image": { + "image_url": "image_url_value", + "on_click": { + "action": { + "function": "function_value", + "parameters": [ + { + "key": "key_value", + "value": "value_value", + } + ], + "load_indicator": 1, + "persist_values": True, + "interaction": 1, + }, + "open_link": { + "url": "url_value", + "open_as": 1, + "on_close": 1, + }, + "open_dynamic_link_action": {}, + "card": {}, + }, + "alt_text": "alt_text_value", + }, + "decorated_text": { + "icon": { + "known_icon": "known_icon_value", + "icon_url": "icon_url_value", + "material_icon": { + "name": "name_value", + "fill": True, + "weight": 648, + "grade": 515, + }, + "alt_text": "alt_text_value", + "image_type": 1, + }, + "start_icon": {}, + "top_label": "top_label_value", + "text": "text_value", + "wrap_text": True, + "bottom_label": "bottom_label_value", + "on_click": {}, + "button": { + "text": "text_value", + "icon": {}, + "color": { + "red": 0.315, + "green": 0.529, + "blue": 0.424, + "alpha": {"value": 0.541}, + }, + "on_click": {}, + "disabled": True, + "alt_text": "alt_text_value", + }, + "switch_control": { + "name": "name_value", + "value": "value_value", + "selected": True, + "on_change_action": {}, + "control_type": 1, + }, + "end_icon": {}, + }, + "button_list": {"buttons": {}}, + "text_input": { + "name": "name_value", + "label": "label_value", + "hint_text": "hint_text_value", + "value": "value_value", + "type_": 1, + "on_change_action": {}, + "initial_suggestions": { + "items": [{"text": "text_value"}] + }, + "auto_complete_action": {}, + "placeholder_text": "placeholder_text_value", + }, + "selection_input": { + "name": "name_value", + "label": "label_value", + "type_": 1, + "items": [ + { + "text": "text_value", + "value": "value_value", + "selected": True, + "start_icon_uri": "start_icon_uri_value", + "bottom_text": "bottom_text_value", + } + ], + "on_change_action": {}, + "multi_select_max_selected_items": 3288, + "multi_select_min_query_length": 3107, + "external_data_source": {}, + "platform_data_source": { + "common_data_source": 1 + }, + }, + "date_time_picker": { + "name": "name_value", + "label": "label_value", + "type_": 1, + "value_ms_epoch": 1482, + "timezone_offset_date": 2126, + "on_change_action": {}, + }, + "divider": {}, + "grid": { + "title": "title_value", + "items": [ + { + "id": "id_value", + "image": { + "image_uri": "image_uri_value", + "alt_text": "alt_text_value", + "crop_style": { + "type_": 1, + "aspect_ratio": 0.1278, + }, + "border_style": { + "type_": 1, + "stroke_color": {}, + "corner_radius": 1392, + }, + }, + "title": "title_value", + "subtitle": "subtitle_value", + "layout": 1, + } + ], + "border_style": {}, + "column_count": 1302, + "on_click": {}, + }, + "columns": { + "column_items": [ + { + "horizontal_size_style": 1, + "horizontal_alignment": 1, + "vertical_alignment": 1, + "widgets": [ + { + "text_paragraph": {}, + "image": {}, + "decorated_text": {}, + "button_list": {}, + "text_input": {}, + "selection_input": {}, + "date_time_picker": {}, + } + ], + } + ] + }, + "horizontal_alignment": 1, + } + ], + "collapsible": True, + "uncollapsible_widgets_count": 2891, + } + ], + "section_divider_style": 1, + "card_actions": [ + {"action_label": "action_label_value", "on_click": {}} + ], + "name": "name_value", + "fixed_footer": {"primary_button": {}, "secondary_button": {}}, + "display_style": 1, + "peek_card_header": {}, + }, + } + ], + "annotations": [ + { + "type_": 1, + "start_index": 1189, + "length": 642, + "user_mention": {"user": {}, "type_": 1}, + "slash_command": { + "bot": {}, + "type_": 1, + "command_name": "command_name_value", + "command_id": 1035, + "triggers_dialog": True, + }, + "rich_link_metadata": { + "uri": "uri_value", + "rich_link_type": 1, + "drive_link_data": { + "drive_data_ref": {"drive_file_id": "drive_file_id_value"}, + "mime_type": "mime_type_value", + }, + }, + } + ], + "thread": {"name": "name_value", "thread_key": "thread_key_value"}, + "space": { + "name": "name_value", + "type_": 1, + "space_type": 1, + "single_user_bot_dm": True, + "threaded": True, + "display_name": "display_name_value", + "external_user_allowed": True, + "space_threading_state": 2, + "space_details": { + "description": "description_value", + "guidelines": "guidelines_value", + }, + "space_history_state": 1, + "import_mode": True, + "create_time": {}, + "admin_installed": True, + "access_settings": {"access_state": 1, "audience": "audience_value"}, + "space_uri": "space_uri_value", + }, + "fallback_text": "fallback_text_value", + "action_response": { + "type_": 1, + "url": "url_value", + "dialog_action": { + "dialog": {"body": {}}, + "action_status": { + "status_code": 1, + "user_facing_message": "user_facing_message_value", + }, + }, + "updated_widget": {"suggestions": {"items": {}}, "widget": "widget_value"}, + }, + "argument_text": "argument_text_value", + "slash_command": {"command_id": 1035}, + "attachment": [ + { + "name": "name_value", + "content_name": "content_name_value", + "content_type": "content_type_value", + "attachment_data_ref": { + "resource_name": "resource_name_value", + "attachment_upload_token": "attachment_upload_token_value", + }, + "drive_data_ref": {}, + "thumbnail_uri": "thumbnail_uri_value", + "download_uri": "download_uri_value", + "source": 1, + } + ], + "matched_url": {"url": "url_value"}, + "thread_reply": True, + "client_assigned_message_id": "client_assigned_message_id_value", + "emoji_reaction_summaries": [ + { + "emoji": { + "unicode": "unicode_value", + "custom_emoji": {"uid": "uid_value"}, + }, + "reaction_count": 1501, + } + ], + "private_message_viewer": {}, + "deletion_metadata": {"deletion_type": 1}, + "quoted_message_metadata": {"name": "name_value", "last_update_time": {}}, + "attached_gifs": [{"uri": "uri_value"}], + "accessory_widgets": [{"button_list": {}}], + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = gc_message.CreateMessageRequest.meta.fields["message"] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["message"].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["message"][field])): + del request_init["message"][field][i][subfield] + else: + del request_init["message"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_message.Message( + name="name_value", + text="text_value", + formatted_text="formatted_text_value", + fallback_text="fallback_text_value", + argument_text="argument_text_value", + thread_reply=True, + client_assigned_message_id="client_assigned_message_id_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_message.Message.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.create_message(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, gc_message.Message) + assert response.name == "name_value" + assert response.text == "text_value" + assert response.formatted_text == "formatted_text_value" + assert response.fallback_text == "fallback_text_value" + assert response.argument_text == "argument_text_value" + assert response.thread_reply is True + assert response.client_assigned_message_id == "client_assigned_message_id_value" + + +def test_create_message_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.create_message in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.create_message] = mock_rpc + + request = {} + client.create_message(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.create_message(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_create_message_rest_required_fields( + request_type=gc_message.CreateMessageRequest, +): + transport_class = transports.ChatServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_message._get_unset_required_fields(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() + ).create_message._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "message_id", + "message_reply_option", + "request_id", + "thread_key", + ) + ) + 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" + + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gc_message.Message() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = gc_message.Message.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.create_message(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_message_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_message._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "messageId", + "messageReplyOption", + "requestId", + "threadKey", + ) + ) + & set( + ( + "parent", + "message", + ) + ) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_message_rest_interceptors(null_interceptor): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ChatServiceRestInterceptor(), + ) + client = ChatServiceClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ChatServiceRestInterceptor, "post_create_message" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_create_message" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gc_message.CreateMessageRequest.pb( + gc_message.CreateMessageRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gc_message.Message.to_json(gc_message.Message()) + + request = gc_message.CreateMessageRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gc_message.Message() + + client.create_message( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_create_message_rest_bad_request( + transport: str = "rest", request_type=gc_message.CreateMessageRequest +): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.create_message(request) + + +def test_create_message_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_message.Message() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "spaces/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + message=gc_message.Message(name="name_value"), + message_id="message_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_message.Message.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_message(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=spaces/*}/messages" % client.transport._host, args[1] + ) + + +def test_create_message_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_message( + gc_message.CreateMessageRequest(), + parent="parent_value", + message=gc_message.Message(name="name_value"), + message_id="message_id_value", + ) + + +def test_create_message_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + message.ListMessagesRequest, + dict, + ], +) +def test_list_messages_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = message.ListMessagesResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = message.ListMessagesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_messages(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListMessagesPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_messages_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.list_messages in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.list_messages] = mock_rpc + + request = {} + client.list_messages(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_messages(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_messages_rest_required_fields(request_type=message.ListMessagesRequest): + transport_class = transports.ChatServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_messages._get_unset_required_fields(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_messages._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", + "show_deleted", + ) + ) + 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" + + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = message.ListMessagesResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = message.ListMessagesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_messages(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_messages_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_messages._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + "showDeleted", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_messages_rest_interceptors(null_interceptor): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ChatServiceRestInterceptor(), + ) + client = ChatServiceClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ChatServiceRestInterceptor, "post_list_messages" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_list_messages" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = message.ListMessagesRequest.pb(message.ListMessagesRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = message.ListMessagesResponse.to_json( + message.ListMessagesResponse() + ) + + request = message.ListMessagesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = message.ListMessagesResponse() + + client.list_messages( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_messages_rest_bad_request( + transport: str = "rest", request_type=message.ListMessagesRequest +): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_messages(request) + + +def test_list_messages_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = message.ListMessagesResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "spaces/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = message.ListMessagesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_messages(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=spaces/*}/messages" % client.transport._host, args[1] + ) + + +def test_list_messages_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_messages( + message.ListMessagesRequest(), + parent="parent_value", + ) + + +def test_list_messages_rest_pager(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + message.ListMessagesResponse( + messages=[ + message.Message(), + message.Message(), + message.Message(), + ], + next_page_token="abc", + ), + message.ListMessagesResponse( + messages=[], + next_page_token="def", + ), + message.ListMessagesResponse( + messages=[ + message.Message(), + ], + next_page_token="ghi", + ), + message.ListMessagesResponse( + messages=[ + message.Message(), + message.Message(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple(message.ListMessagesResponse.to_json(x) for x in response) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "spaces/sample1"} + + pager = client.list_messages(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, message.Message) for i in results) + + pages = list(client.list_messages(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + membership.ListMembershipsRequest, + dict, + ], +) +def test_list_memberships_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = membership.ListMembershipsResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = membership.ListMembershipsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_memberships(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListMembershipsPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_memberships_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.list_memberships in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_memberships + ] = mock_rpc + + request = {} + client.list_memberships(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_memberships(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_memberships_rest_required_fields( + request_type=membership.ListMembershipsRequest, +): + transport_class = transports.ChatServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_memberships._get_unset_required_fields(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_memberships._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", + "show_groups", + "show_invited", + ) + ) + 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" + + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = membership.ListMembershipsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = membership.ListMembershipsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_memberships(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_memberships_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_memberships._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + "showGroups", + "showInvited", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_memberships_rest_interceptors(null_interceptor): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ChatServiceRestInterceptor(), + ) + client = ChatServiceClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ChatServiceRestInterceptor, "post_list_memberships" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_list_memberships" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = membership.ListMembershipsRequest.pb( + membership.ListMembershipsRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = membership.ListMembershipsResponse.to_json( + membership.ListMembershipsResponse() + ) + + request = membership.ListMembershipsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = membership.ListMembershipsResponse() + + client.list_memberships( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_memberships_rest_bad_request( + transport: str = "rest", request_type=membership.ListMembershipsRequest +): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_memberships(request) + + +def test_list_memberships_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = membership.ListMembershipsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "spaces/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = membership.ListMembershipsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_memberships(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=spaces/*}/members" % client.transport._host, args[1] + ) + + +def test_list_memberships_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_memberships( + membership.ListMembershipsRequest(), + parent="parent_value", + ) + + +def test_list_memberships_rest_pager(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + membership.ListMembershipsResponse( + memberships=[ + membership.Membership(), + membership.Membership(), + membership.Membership(), + ], + next_page_token="abc", + ), + membership.ListMembershipsResponse( + memberships=[], + next_page_token="def", + ), + membership.ListMembershipsResponse( + memberships=[ + membership.Membership(), + ], + next_page_token="ghi", + ), + membership.ListMembershipsResponse( + memberships=[ membership.Membership(), membership.Membership(), ], @@ -13776,181 +14743,1083 @@ def test_update_message_rest(request_type): }, }, } - ], - "thread": {"name": "name_value", "thread_key": "thread_key_value"}, - "space": { - "name": "name_value", - "type_": 1, - "space_type": 1, - "single_user_bot_dm": True, - "threaded": True, - "display_name": "display_name_value", - "external_user_allowed": True, - "space_threading_state": 2, - "space_details": { - "description": "description_value", - "guidelines": "guidelines_value", - }, - "space_history_state": 1, - "import_mode": True, - "create_time": {}, - "admin_installed": True, - "access_settings": {"access_state": 1, "audience": "audience_value"}, - "space_uri": "space_uri_value", - }, - "fallback_text": "fallback_text_value", - "action_response": { - "type_": 1, - "url": "url_value", - "dialog_action": { - "dialog": {"body": {}}, - "action_status": { - "status_code": 1, - "user_facing_message": "user_facing_message_value", - }, - }, - "updated_widget": {"suggestions": {"items": {}}, "widget": "widget_value"}, - }, - "argument_text": "argument_text_value", - "slash_command": {"command_id": 1035}, - "attachment": [ - { - "name": "name_value", - "content_name": "content_name_value", - "content_type": "content_type_value", - "attachment_data_ref": { - "resource_name": "resource_name_value", - "attachment_upload_token": "attachment_upload_token_value", - }, - "drive_data_ref": {}, - "thumbnail_uri": "thumbnail_uri_value", - "download_uri": "download_uri_value", - "source": 1, + ], + "thread": {"name": "name_value", "thread_key": "thread_key_value"}, + "space": { + "name": "name_value", + "type_": 1, + "space_type": 1, + "single_user_bot_dm": True, + "threaded": True, + "display_name": "display_name_value", + "external_user_allowed": True, + "space_threading_state": 2, + "space_details": { + "description": "description_value", + "guidelines": "guidelines_value", + }, + "space_history_state": 1, + "import_mode": True, + "create_time": {}, + "admin_installed": True, + "access_settings": {"access_state": 1, "audience": "audience_value"}, + "space_uri": "space_uri_value", + }, + "fallback_text": "fallback_text_value", + "action_response": { + "type_": 1, + "url": "url_value", + "dialog_action": { + "dialog": {"body": {}}, + "action_status": { + "status_code": 1, + "user_facing_message": "user_facing_message_value", + }, + }, + "updated_widget": {"suggestions": {"items": {}}, "widget": "widget_value"}, + }, + "argument_text": "argument_text_value", + "slash_command": {"command_id": 1035}, + "attachment": [ + { + "name": "name_value", + "content_name": "content_name_value", + "content_type": "content_type_value", + "attachment_data_ref": { + "resource_name": "resource_name_value", + "attachment_upload_token": "attachment_upload_token_value", + }, + "drive_data_ref": {}, + "thumbnail_uri": "thumbnail_uri_value", + "download_uri": "download_uri_value", + "source": 1, + } + ], + "matched_url": {"url": "url_value"}, + "thread_reply": True, + "client_assigned_message_id": "client_assigned_message_id_value", + "emoji_reaction_summaries": [ + { + "emoji": { + "unicode": "unicode_value", + "custom_emoji": {"uid": "uid_value"}, + }, + "reaction_count": 1501, + } + ], + "private_message_viewer": {}, + "deletion_metadata": {"deletion_type": 1}, + "quoted_message_metadata": {"name": "name_value", "last_update_time": {}}, + "attached_gifs": [{"uri": "uri_value"}], + "accessory_widgets": [{"button_list": {}}], + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = gc_message.UpdateMessageRequest.meta.fields["message"] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["message"].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["message"][field])): + del request_init["message"][field][i][subfield] + else: + del request_init["message"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_message.Message( + name="name_value", + text="text_value", + formatted_text="formatted_text_value", + fallback_text="fallback_text_value", + argument_text="argument_text_value", + thread_reply=True, + client_assigned_message_id="client_assigned_message_id_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_message.Message.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.update_message(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, gc_message.Message) + assert response.name == "name_value" + assert response.text == "text_value" + assert response.formatted_text == "formatted_text_value" + assert response.fallback_text == "fallback_text_value" + assert response.argument_text == "argument_text_value" + assert response.thread_reply is True + assert response.client_assigned_message_id == "client_assigned_message_id_value" + + +def test_update_message_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.update_message in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.update_message] = mock_rpc + + request = {} + client.update_message(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.update_message(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_update_message_rest_required_fields( + request_type=gc_message.UpdateMessageRequest, +): + transport_class = transports.ChatServiceRestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_message._get_unset_required_fields(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._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", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gc_message.Message() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "put", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = gc_message.Message.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.update_message(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_message_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_message._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "allowMissing", + "updateMask", + ) + ) + & set(("message",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_message_rest_interceptors(null_interceptor): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ChatServiceRestInterceptor(), + ) + client = ChatServiceClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ChatServiceRestInterceptor, "post_update_message" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_update_message" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gc_message.UpdateMessageRequest.pb( + gc_message.UpdateMessageRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gc_message.Message.to_json(gc_message.Message()) + + request = gc_message.UpdateMessageRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gc_message.Message() + + client.update_message( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_update_message_rest_bad_request( + transport: str = "rest", request_type=gc_message.UpdateMessageRequest +): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"message": {"name": "spaces/sample1/messages/sample2"}} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.update_message(request) + + +def test_update_message_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_message.Message() + + # get arguments that satisfy an http rule for this method + sample_request = {"message": {"name": "spaces/sample1/messages/sample2"}} + + # get truthy value for each flattened field + mock_args = dict( + message=gc_message.Message(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_message.Message.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.update_message(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{message.name=spaces/*/messages/*}" % client.transport._host, args[1] + ) + + +def test_update_message_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_message( + gc_message.UpdateMessageRequest(), + message=gc_message.Message(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_update_message_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + message.DeleteMessageRequest, + dict, + ], +) +def test_delete_message_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/messages/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.delete_message(request) + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_message_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.delete_message in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.delete_message] = mock_rpc + + request = {} + client.delete_message(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_message(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_delete_message_rest_required_fields(request_type=message.DeleteMessageRequest): + transport_class = transports.ChatServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_message._get_unset_required_fields(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._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("force",)) + 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" + + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = None + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, } - ], - "matched_url": {"url": "url_value"}, - "thread_reply": True, - "client_assigned_message_id": "client_assigned_message_id_value", - "emoji_reaction_summaries": [ - { - "emoji": { - "unicode": "unicode_value", - "custom_emoji": {"uid": "uid_value"}, - }, - "reaction_count": 1501, + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.delete_message(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_message_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_message._get_unset_required_fields({}) + assert set(unset_fields) == (set(("force",)) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_message_rest_interceptors(null_interceptor): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ChatServiceRestInterceptor(), + ) + client = ChatServiceClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_delete_message" + ) as pre: + pre.assert_not_called() + pb_message = message.DeleteMessageRequest.pb(message.DeleteMessageRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + + request = message.DeleteMessageRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + + client.delete_message( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + + +def test_delete_message_rest_bad_request( + transport: str = "rest", request_type=message.DeleteMessageRequest +): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/messages/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.delete_message(request) + + +def test_delete_message_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "spaces/sample1/messages/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.delete_message(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=spaces/*/messages/*}" % client.transport._host, args[1] + ) + + +def test_delete_message_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_message( + message.DeleteMessageRequest(), + name="name_value", + ) + + +def test_delete_message_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + attachment.GetAttachmentRequest, + dict, + ], +) +def test_get_attachment_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/messages/sample2/attachments/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = attachment.Attachment( + name="name_value", + content_name="content_name_value", + content_type="content_type_value", + thumbnail_uri="thumbnail_uri_value", + download_uri="download_uri_value", + source=attachment.Attachment.Source.DRIVE_FILE, + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = attachment.Attachment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_attachment(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, attachment.Attachment) + assert response.name == "name_value" + assert response.content_name == "content_name_value" + assert response.content_type == "content_type_value" + assert response.thumbnail_uri == "thumbnail_uri_value" + assert response.download_uri == "download_uri_value" + assert response.source == attachment.Attachment.Source.DRIVE_FILE + + +def test_get_attachment_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.get_attachment in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.get_attachment] = mock_rpc + + request = {} + client.get_attachment(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_attachment(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_get_attachment_rest_required_fields( + request_type=attachment.GetAttachmentRequest, +): + transport_class = transports.ChatServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_attachment._get_unset_required_fields(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_attachment._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" + + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = attachment.Attachment() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, } - ], - "private_message_viewer": {}, - "deletion_metadata": {"deletion_type": 1}, - "quoted_message_metadata": {"name": "name_value", "last_update_time": {}}, - "attached_gifs": [{"uri": "uri_value"}], - "accessory_widgets": [{"button_list": {}}], - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = attachment.Attachment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_attachment(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_attachment_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_attachment._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_attachment_rest_interceptors(null_interceptor): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ChatServiceRestInterceptor(), + ) + client = ChatServiceClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ChatServiceRestInterceptor, "post_get_attachment" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_get_attachment" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = attachment.GetAttachmentRequest.pb( + attachment.GetAttachmentRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = attachment.Attachment.to_json( + attachment.Attachment() + ) - # Determine if the message type is proto-plus or protobuf - test_field = gc_message.UpdateMessageRequest.meta.fields["message"] + request = attachment.GetAttachmentRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = attachment.Attachment() - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] + client.get_attachment( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + pre.assert_called_once() + post.assert_called_once() - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] +def test_get_attachment_rest_bad_request( + transport: str = "rest", request_type=attachment.GetAttachmentRequest +): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - subfields_not_in_runtime = [] + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/messages/sample2/attachments/sample3"} + request = request_type(**request_init) - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["message"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_attachment(request) - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["message"][field])): - del request_init["message"][field][i][subfield] - else: - del request_init["message"][field][subfield] - request = request_type(**request_init) +def test_get_attachment_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_message.Message( + return_value = attachment.Attachment() + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "spaces/sample1/messages/sample2/attachments/sample3"} + + # get truthy value for each flattened field + mock_args = dict( name="name_value", - text="text_value", - formatted_text="formatted_text_value", - fallback_text="fallback_text_value", - argument_text="argument_text_value", - thread_reply=True, - client_assigned_message_id="client_assigned_message_id_value", ) + mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_message.Message.pb(return_value) + return_value = attachment.Attachment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_attachment(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=spaces/*/messages/*/attachments/*}" % client.transport._host, + args[1], + ) + + +def test_get_attachment_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_attachment( + attachment.GetAttachmentRequest(), + name="name_value", + ) + + +def test_get_attachment_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + attachment.UploadAttachmentRequest, + dict, + ], +) +def test_upload_attachment_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = attachment.UploadAttachmentResponse() + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = attachment.UploadAttachmentResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_message(request) + response = client.upload_attachment(request) # Establish that the response is the type that we expect. - assert isinstance(response, gc_message.Message) - assert response.name == "name_value" - assert response.text == "text_value" - assert response.formatted_text == "formatted_text_value" - assert response.fallback_text == "fallback_text_value" - assert response.argument_text == "argument_text_value" - assert response.thread_reply is True - assert response.client_assigned_message_id == "client_assigned_message_id_value" + assert isinstance(response, attachment.UploadAttachmentResponse) -def test_update_message_rest_use_cached_wrapped_rpc(): +def test_upload_attachment_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -13964,34 +15833,38 @@ def test_update_message_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_message in client._transport._wrapped_methods + assert client._transport.upload_attachment in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.update_message] = mock_rpc + client._transport._wrapped_methods[ + client._transport.upload_attachment + ] = mock_rpc request = {} - client.update_message(request) + client.upload_attachment(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_message(request) + client.upload_attachment(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_message_rest_required_fields( - request_type=gc_message.UpdateMessageRequest, +def test_upload_attachment_rest_required_fields( + request_type=attachment.UploadAttachmentRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} + request_init["parent"] = "" + request_init["filename"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -14002,24 +15875,24 @@ def test_update_message_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_message._get_unset_required_fields(jsonified_request) + ).upload_attachment._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" + jsonified_request["filename"] = "filename_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_message._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", - ) - ) + ).upload_attachment._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" + assert "filename" in jsonified_request + assert jsonified_request["filename"] == "filename_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -14028,7 +15901,7 @@ def test_update_message_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gc_message.Message() + return_value = attachment.UploadAttachmentResponse() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -14040,7 +15913,7 @@ def test_update_message_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "put", + "method": "post", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -14050,38 +15923,38 @@ def test_update_message_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_message.Message.pb(return_value) + return_value = attachment.UploadAttachmentResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_message(request) + response = client.upload_attachment(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_message_rest_unset_required_fields(): +def test_upload_attachment_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_message._get_unset_required_fields({}) + unset_fields = transport.upload_attachment._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "allowMissing", - "updateMask", + "parent", + "filename", ) ) - & set(("message",)) ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_message_rest_interceptors(null_interceptor): +def test_upload_attachment_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -14094,14 +15967,14 @@ def test_update_message_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_update_message" + transports.ChatServiceRestInterceptor, "post_upload_attachment" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_update_message" + transports.ChatServiceRestInterceptor, "pre_upload_attachment" ) as pre: pre.assert_not_called() - post.assert_not_called() - pb_message = gc_message.UpdateMessageRequest.pb( - gc_message.UpdateMessageRequest() + post.assert_not_called() + pb_message = attachment.UploadAttachmentRequest.pb( + attachment.UploadAttachmentRequest() ) transcode.return_value = { "method": "post", @@ -14113,17 +15986,19 @@ def test_update_message_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gc_message.Message.to_json(gc_message.Message()) + req.return_value._content = attachment.UploadAttachmentResponse.to_json( + attachment.UploadAttachmentResponse() + ) - request = gc_message.UpdateMessageRequest() + request = attachment.UploadAttachmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gc_message.Message() + post.return_value = attachment.UploadAttachmentResponse() - client.update_message( + client.upload_attachment( request, metadata=[ ("key", "val"), @@ -14135,8 +16010,8 @@ def test_update_message_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_message_rest_bad_request( - transport: str = "rest", request_type=gc_message.UpdateMessageRequest +def test_upload_attachment_rest_bad_request( + transport: str = "rest", request_type=attachment.UploadAttachmentRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -14144,7 +16019,7 @@ def test_update_message_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"message": {"name": "spaces/sample1/messages/sample2"}} + request_init = {"parent": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -14156,67 +16031,10 @@ def test_update_message_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.update_message(request) - - -def test_update_message_rest_flattened(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = gc_message.Message() - - # get arguments that satisfy an http rule for this method - sample_request = {"message": {"name": "spaces/sample1/messages/sample2"}} - - # get truthy value for each flattened field - mock_args = dict( - message=gc_message.Message(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gc_message.Message.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.update_message(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{message.name=spaces/*/messages/*}" % client.transport._host, args[1] - ) - - -def test_update_message_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.update_message( - gc_message.UpdateMessageRequest(), - message=gc_message.Message(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) + client.upload_attachment(request) -def test_update_message_rest_error(): +def test_upload_attachment_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -14225,39 +16043,44 @@ def test_update_message_rest_error(): @pytest.mark.parametrize( "request_type", [ - message.DeleteMessageRequest, + space.ListSpacesRequest, dict, ], ) -def test_delete_message_rest(request_type): +def test_list_spaces_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/messages/sample2"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = space.ListSpacesResponse( + next_page_token="next_page_token_value", + ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + # Convert return value to protobuf type + return_value = space.ListSpacesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_message(request) + response = client.list_spaces(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, pagers.ListSpacesPager) + assert response.next_page_token == "next_page_token_value" -def test_delete_message_rest_use_cached_wrapped_rpc(): +def test_list_spaces_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -14271,110 +16094,30 @@ def test_delete_message_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_message in client._transport._wrapped_methods + assert client._transport.list_spaces in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.delete_message] = mock_rpc + client._transport._wrapped_methods[client._transport.list_spaces] = mock_rpc request = {} - client.delete_message(request) + client.list_spaces(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_message(request) + client.list_spaces(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_message_rest_required_fields(request_type=message.DeleteMessageRequest): - transport_class = transports.ChatServiceRestTransport - - request_init = {} - request_init["name"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) - ) - - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_message._get_unset_required_fields(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._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("force",)) - 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" - - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = None - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "delete", - "query_params": pb_request, - } - transcode.return_value = transcode_result - - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - response = client.delete_message(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_delete_message_rest_unset_required_fields(): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.delete_message._get_unset_required_fields({}) - assert set(unset_fields) == (set(("force",)) & set(("name",))) - - @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_message_rest_interceptors(null_interceptor): +def test_list_spaces_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -14387,10 +16130,13 @@ def test_delete_message_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_delete_message" + transports.ChatServiceRestInterceptor, "post_list_spaces" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_list_spaces" ) as pre: pre.assert_not_called() - pb_message = message.DeleteMessageRequest.pb(message.DeleteMessageRequest()) + post.assert_not_called() + pb_message = space.ListSpacesRequest.pb(space.ListSpacesRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -14401,15 +16147,19 @@ def test_delete_message_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() + req.return_value._content = space.ListSpacesResponse.to_json( + space.ListSpacesResponse() + ) - request = message.DeleteMessageRequest() + request = space.ListSpacesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = space.ListSpacesResponse() - client.delete_message( + client.list_spaces( request, metadata=[ ("key", "val"), @@ -14418,10 +16168,11 @@ def test_delete_message_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() -def test_delete_message_rest_bad_request( - transport: str = "rest", request_type=message.DeleteMessageRequest +def test_list_spaces_rest_bad_request( + transport: str = "rest", request_type=space.ListSpacesRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -14429,7 +16180,7 @@ def test_delete_message_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/messages/sample2"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -14441,119 +16192,136 @@ def test_delete_message_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.delete_message(request) + client.list_spaces(request) -def test_delete_message_rest_flattened(): +def test_list_spaces_rest_pager(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "spaces/sample1/messages/sample2"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.delete_message(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=spaces/*/messages/*}" % client.transport._host, args[1] + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + space.ListSpacesResponse( + spaces=[ + space.Space(), + space.Space(), + space.Space(), + ], + next_page_token="abc", + ), + space.ListSpacesResponse( + spaces=[], + next_page_token="def", + ), + space.ListSpacesResponse( + spaces=[ + space.Space(), + ], + next_page_token="ghi", + ), + space.ListSpacesResponse( + spaces=[ + space.Space(), + space.Space(), + ], + ), ) + # Two responses for two calls + response = response + response + # Wrap the values into proper Response objs + response = tuple(space.ListSpacesResponse.to_json(x) for x in response) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values -def test_delete_message_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) + sample_request = {} - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.delete_message( - message.DeleteMessageRequest(), - name="name_value", - ) + pager = client.list_spaces(request=sample_request) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, space.Space) for i in results) -def test_delete_message_rest_error(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + pages = list(client.list_spaces(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token @pytest.mark.parametrize( "request_type", [ - attachment.GetAttachmentRequest, + space.GetSpaceRequest, dict, ], ) -def test_get_attachment_rest(request_type): +def test_get_space_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/messages/sample2/attachments/sample3"} + request_init = {"name": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = attachment.Attachment( + return_value = space.Space( name="name_value", - content_name="content_name_value", - content_type="content_type_value", - thumbnail_uri="thumbnail_uri_value", - download_uri="download_uri_value", - source=attachment.Attachment.Source.DRIVE_FILE, + type_=space.Space.Type.ROOM, + space_type=space.Space.SpaceType.SPACE, + single_user_bot_dm=True, + threaded=True, + display_name="display_name_value", + external_user_allowed=True, + space_threading_state=space.Space.SpaceThreadingState.THREADED_MESSAGES, + space_history_state=history_state.HistoryState.HISTORY_OFF, + import_mode=True, + admin_installed=True, + space_uri="space_uri_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = attachment.Attachment.pb(return_value) + return_value = space.Space.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_attachment(request) + response = client.get_space(request) # Establish that the response is the type that we expect. - assert isinstance(response, attachment.Attachment) + assert isinstance(response, space.Space) assert response.name == "name_value" - assert response.content_name == "content_name_value" - assert response.content_type == "content_type_value" - assert response.thumbnail_uri == "thumbnail_uri_value" - assert response.download_uri == "download_uri_value" - assert response.source == attachment.Attachment.Source.DRIVE_FILE + assert response.type_ == space.Space.Type.ROOM + assert response.space_type == space.Space.SpaceType.SPACE + assert response.single_user_bot_dm is True + assert response.threaded is True + assert response.display_name == "display_name_value" + assert response.external_user_allowed is True + assert ( + response.space_threading_state + == space.Space.SpaceThreadingState.THREADED_MESSAGES + ) + assert response.space_history_state == history_state.HistoryState.HISTORY_OFF + assert response.import_mode is True + assert response.admin_installed is True + assert response.space_uri == "space_uri_value" -def test_get_attachment_rest_use_cached_wrapped_rpc(): +def test_get_space_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -14567,31 +16335,29 @@ def test_get_attachment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_attachment in client._transport._wrapped_methods + assert client._transport.get_space in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.get_attachment] = mock_rpc + client._transport._wrapped_methods[client._transport.get_space] = mock_rpc request = {} - client.get_attachment(request) + client.get_space(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_attachment(request) + client.get_space(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_get_attachment_rest_required_fields( - request_type=attachment.GetAttachmentRequest, -): +def test_get_space_rest_required_fields(request_type=space.GetSpaceRequest): transport_class = transports.ChatServiceRestTransport request_init = {} @@ -14606,7 +16372,7 @@ def test_get_attachment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_attachment._get_unset_required_fields(jsonified_request) + ).get_space._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -14615,7 +16381,7 @@ def test_get_attachment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_attachment._get_unset_required_fields(jsonified_request) + ).get_space._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -14629,7 +16395,7 @@ def test_get_attachment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = attachment.Attachment() + return_value = space.Space() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -14650,30 +16416,30 @@ def test_get_attachment_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = attachment.Attachment.pb(return_value) + return_value = space.Space.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_attachment(request) + response = client.get_space(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_attachment_rest_unset_required_fields(): +def test_get_space_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_attachment._get_unset_required_fields({}) + unset_fields = transport.get_space._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_attachment_rest_interceptors(null_interceptor): +def test_get_space_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -14686,15 +16452,13 @@ def test_get_attachment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_get_attachment" + transports.ChatServiceRestInterceptor, "post_get_space" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_get_attachment" + transports.ChatServiceRestInterceptor, "pre_get_space" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = attachment.GetAttachmentRequest.pb( - attachment.GetAttachmentRequest() - ) + pb_message = space.GetSpaceRequest.pb(space.GetSpaceRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -14705,19 +16469,17 @@ def test_get_attachment_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = attachment.Attachment.to_json( - attachment.Attachment() - ) + req.return_value._content = space.Space.to_json(space.Space()) - request = attachment.GetAttachmentRequest() + request = space.GetSpaceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = attachment.Attachment() + post.return_value = space.Space() - client.get_attachment( + client.get_space( request, metadata=[ ("key", "val"), @@ -14729,8 +16491,8 @@ def test_get_attachment_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_attachment_rest_bad_request( - transport: str = "rest", request_type=attachment.GetAttachmentRequest +def test_get_space_rest_bad_request( + transport: str = "rest", request_type=space.GetSpaceRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -14738,7 +16500,7 @@ def test_get_attachment_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/messages/sample2/attachments/sample3"} + request_init = {"name": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -14750,10 +16512,10 @@ def test_get_attachment_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_attachment(request) + client.get_space(request) -def test_get_attachment_rest_flattened(): +def test_get_space_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -14762,10 +16524,10 @@ def test_get_attachment_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = attachment.Attachment() + return_value = space.Space() # get arguments that satisfy an http rule for this method - sample_request = {"name": "spaces/sample1/messages/sample2/attachments/sample3"} + sample_request = {"name": "spaces/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -14777,24 +16539,23 @@ def test_get_attachment_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = attachment.Attachment.pb(return_value) + return_value = space.Space.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_attachment(**mock_args) + client.get_space(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=spaces/*/messages/*/attachments/*}" % client.transport._host, - args[1], + "%s/v1/{name=spaces/*}" % client.transport._host, args[1] ) -def test_get_attachment_rest_flattened_error(transport: str = "rest"): +def test_get_space_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -14803,13 +16564,13 @@ def test_get_attachment_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_attachment( - attachment.GetAttachmentRequest(), + client.get_space( + space.GetSpaceRequest(), name="name_value", ) -def test_get_attachment_rest_error(): +def test_get_space_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -14818,41 +16579,156 @@ def test_get_attachment_rest_error(): @pytest.mark.parametrize( "request_type", [ - attachment.UploadAttachmentRequest, + gc_space.CreateSpaceRequest, dict, ], ) -def test_upload_attachment_rest(request_type): +def test_create_space_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} + # send a request that will satisfy transcoding + request_init = {} + request_init["space"] = { + "name": "name_value", + "type_": 1, + "space_type": 1, + "single_user_bot_dm": True, + "threaded": True, + "display_name": "display_name_value", + "external_user_allowed": True, + "space_threading_state": 2, + "space_details": { + "description": "description_value", + "guidelines": "guidelines_value", + }, + "space_history_state": 1, + "import_mode": True, + "create_time": {"seconds": 751, "nanos": 543}, + "admin_installed": True, + "access_settings": {"access_state": 1, "audience": "audience_value"}, + "space_uri": "space_uri_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = gc_space.CreateSpaceRequest.meta.fields["space"] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["space"].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["space"][field])): + del request_init["space"][field][i][subfield] + else: + del request_init["space"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = attachment.UploadAttachmentResponse() + return_value = gc_space.Space( + name="name_value", + type_=gc_space.Space.Type.ROOM, + space_type=gc_space.Space.SpaceType.SPACE, + single_user_bot_dm=True, + threaded=True, + display_name="display_name_value", + external_user_allowed=True, + space_threading_state=gc_space.Space.SpaceThreadingState.THREADED_MESSAGES, + space_history_state=history_state.HistoryState.HISTORY_OFF, + import_mode=True, + admin_installed=True, + space_uri="space_uri_value", + ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = attachment.UploadAttachmentResponse.pb(return_value) + return_value = gc_space.Space.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.upload_attachment(request) + response = client.create_space(request) # Establish that the response is the type that we expect. - assert isinstance(response, attachment.UploadAttachmentResponse) + assert isinstance(response, gc_space.Space) + assert response.name == "name_value" + assert response.type_ == gc_space.Space.Type.ROOM + assert response.space_type == gc_space.Space.SpaceType.SPACE + assert response.single_user_bot_dm is True + assert response.threaded is True + assert response.display_name == "display_name_value" + assert response.external_user_allowed is True + assert ( + response.space_threading_state + == gc_space.Space.SpaceThreadingState.THREADED_MESSAGES + ) + assert response.space_history_state == history_state.HistoryState.HISTORY_OFF + assert response.import_mode is True + assert response.admin_installed is True + assert response.space_uri == "space_uri_value" -def test_upload_attachment_rest_use_cached_wrapped_rpc(): +def test_create_space_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -14866,38 +16742,32 @@ def test_upload_attachment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.upload_attachment in client._transport._wrapped_methods + assert client._transport.create_space in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[ - client._transport.upload_attachment - ] = mock_rpc + client._transport._wrapped_methods[client._transport.create_space] = mock_rpc request = {} - client.upload_attachment(request) + client.create_space(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.upload_attachment(request) + client.create_space(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_upload_attachment_rest_required_fields( - request_type=attachment.UploadAttachmentRequest, -): +def test_create_space_rest_required_fields(request_type=gc_space.CreateSpaceRequest): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["parent"] = "" - request_init["filename"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -14908,24 +16778,19 @@ def test_upload_attachment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).upload_attachment._get_unset_required_fields(jsonified_request) + ).create_space._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - jsonified_request["filename"] = "filename_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).upload_attachment._get_unset_required_fields(jsonified_request) + ).create_space._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("request_id",)) 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" - assert "filename" in jsonified_request - assert jsonified_request["filename"] == "filename_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -14934,7 +16799,7 @@ def test_upload_attachment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = attachment.UploadAttachmentResponse() + return_value = gc_space.Space() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -14956,201 +16821,30 @@ def test_upload_attachment_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = attachment.UploadAttachmentResponse.pb(return_value) + return_value = gc_space.Space.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.upload_attachment(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_upload_attachment_rest_unset_required_fields(): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.upload_attachment._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "filename", - ) - ) - ) - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_upload_attachment_rest_interceptors(null_interceptor): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.ChatServiceRestInterceptor(), - ) - client = ChatServiceClient(transport=transport) - with mock.patch.object( - type(client.transport._session), "request" - ) as req, mock.patch.object( - path_template, "transcode" - ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_upload_attachment" - ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_upload_attachment" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - pb_message = attachment.UploadAttachmentRequest.pb( - attachment.UploadAttachmentRequest() - ) - transcode.return_value = { - "method": "post", - "uri": "my_uri", - "body": pb_message, - "query_params": pb_message, - } - - req.return_value = Response() - req.return_value.status_code = 200 - req.return_value.request = PreparedRequest() - req.return_value._content = attachment.UploadAttachmentResponse.to_json( - attachment.UploadAttachmentResponse() - ) - - request = attachment.UploadAttachmentRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = attachment.UploadAttachmentResponse() - - client.upload_attachment( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - post.assert_called_once() - - -def test_upload_attachment_rest_bad_request( - transport: str = "rest", request_type=attachment.UploadAttachmentRequest -): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request = request_type(**request_init) - - # Mock the http request call within the method and fake a BadRequest error. - with mock.patch.object(Session, "request") as req, pytest.raises( - core_exceptions.BadRequest - ): - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 400 - response_value.request = Request() - req.return_value = response_value - client.upload_attachment(request) - - -def test_upload_attachment_rest_error(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - -@pytest.mark.parametrize( - "request_type", - [ - space.ListSpacesRequest, - dict, - ], -) -def test_list_spaces_rest(request_type): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # send a request that will satisfy transcoding - request_init = {} - request = request_type(**request_init) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = space.ListSpacesResponse( - next_page_token="next_page_token_value", - ) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = space.ListSpacesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - response = client.list_spaces(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListSpacesPager) - assert response.next_page_token == "next_page_token_value" - - -def test_list_spaces_rest_use_cached_wrapped_rpc(): - # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, - # instead of constructing them on each call - with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() - - # Ensure method has been cached - assert client._transport.list_spaces in client._transport._wrapped_methods - - # Replace cached wrapped function with mock - mock_rpc = mock.Mock() - mock_rpc.return_value.name = ( - "foo" # operation_request.operation in compute client(s) expect a string. - ) - client._transport._wrapped_methods[client._transport.list_spaces] = mock_rpc + response = client.create_space(request) - request = {} - client.list_spaces(request) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - client.list_spaces(request) +def test_create_space_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + unset_fields = transport.create_space._get_unset_required_fields({}) + assert set(unset_fields) == (set(("requestId",)) & set(("space",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_spaces_rest_interceptors(null_interceptor): +def test_create_space_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15163,13 +16857,13 @@ def test_list_spaces_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_list_spaces" + transports.ChatServiceRestInterceptor, "post_create_space" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_list_spaces" + transports.ChatServiceRestInterceptor, "pre_create_space" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = space.ListSpacesRequest.pb(space.ListSpacesRequest()) + pb_message = gc_space.CreateSpaceRequest.pb(gc_space.CreateSpaceRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -15180,19 +16874,17 @@ def test_list_spaces_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = space.ListSpacesResponse.to_json( - space.ListSpacesResponse() - ) + req.return_value._content = gc_space.Space.to_json(gc_space.Space()) - request = space.ListSpacesRequest() + request = gc_space.CreateSpaceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = space.ListSpacesResponse() + post.return_value = gc_space.Space() - client.list_spaces( + client.create_space( request, metadata=[ ("key", "val"), @@ -15204,8 +16896,8 @@ def test_list_spaces_rest_interceptors(null_interceptor): post.assert_called_once() -def test_list_spaces_rest_bad_request( - transport: str = "rest", request_type=space.ListSpacesRequest +def test_create_space_rest_bad_request( + transport: str = "rest", request_type=gc_space.CreateSpaceRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -15225,85 +16917,83 @@ def test_list_spaces_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.list_spaces(request) + client.create_space(request) -def test_list_spaces_rest_pager(transport: str = "rest"): +def test_create_space_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="rest", ) # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - space.ListSpacesResponse( - spaces=[ - space.Space(), - space.Space(), - space.Space(), - ], - next_page_token="abc", - ), - space.ListSpacesResponse( - spaces=[], - next_page_token="def", - ), - space.ListSpacesResponse( - spaces=[ - space.Space(), - ], - next_page_token="ghi", - ), - space.ListSpacesResponse( - spaces=[ - space.Space(), - space.Space(), - ], - ), + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_space.Space() + + # get arguments that satisfy an http rule for this method + sample_request = {} + + # get truthy value for each flattened field + mock_args = dict( + space=gc_space.Space(name="name_value"), ) - # Two responses for two calls - response = response + response + mock_args.update(sample_request) - # Wrap the values into proper Response objs - response = tuple(space.ListSpacesResponse.to_json(x) for x in response) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_space.Space.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value - sample_request = {} + client.create_space(**mock_args) - pager = client.list_spaces(request=sample_request) + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate("%s/v1/spaces" % client.transport._host, args[1]) - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, space.Space) for i in results) - pages = list(client.list_spaces(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +def test_create_space_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_space( + gc_space.CreateSpaceRequest(), + space=gc_space.Space(name="name_value"), + ) + + +def test_create_space_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) @pytest.mark.parametrize( "request_type", [ - space.GetSpaceRequest, + space_setup.SetUpSpaceRequest, dict, ], ) -def test_get_space_rest(request_type): +def test_set_up_space_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -15333,7 +17023,7 @@ def test_get_space_rest(request_type): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_space(request) + response = client.set_up_space(request) # Establish that the response is the type that we expect. assert isinstance(response, space.Space) @@ -15354,7 +17044,7 @@ def test_get_space_rest(request_type): assert response.space_uri == "space_uri_value" -def test_get_space_rest_use_cached_wrapped_rpc(): +def test_set_up_space_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -15368,33 +17058,32 @@ def test_get_space_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_space in client._transport._wrapped_methods + assert client._transport.set_up_space in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.get_space] = mock_rpc + client._transport._wrapped_methods[client._transport.set_up_space] = mock_rpc request = {} - client.get_space(request) + client.set_up_space(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_space(request) + client.set_up_space(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_get_space_rest_required_fields(request_type=space.GetSpaceRequest): +def test_set_up_space_rest_required_fields(request_type=space_setup.SetUpSpaceRequest): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -15405,21 +17094,17 @@ def test_get_space_rest_required_fields(request_type=space.GetSpaceRequest): unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_space._get_unset_required_fields(jsonified_request) + ).set_up_space._get_unset_required_fields(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_space._get_unset_required_fields(jsonified_request) + ).set_up_space._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" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -15440,9 +17125,10 @@ def test_get_space_rest_required_fields(request_type=space.GetSpaceRequest): pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "post", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() @@ -15455,24 +17141,24 @@ def test_get_space_rest_required_fields(request_type=space.GetSpaceRequest): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_space(request) + response = client.set_up_space(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_space_rest_unset_required_fields(): +def test_set_up_space_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_space._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.set_up_space._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("space",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_space_rest_interceptors(null_interceptor): +def test_set_up_space_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15485,13 +17171,13 @@ def test_get_space_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_get_space" + transports.ChatServiceRestInterceptor, "post_set_up_space" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_get_space" + transports.ChatServiceRestInterceptor, "pre_set_up_space" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = space.GetSpaceRequest.pb(space.GetSpaceRequest()) + pb_message = space_setup.SetUpSpaceRequest.pb(space_setup.SetUpSpaceRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -15504,7 +17190,7 @@ def test_get_space_rest_interceptors(null_interceptor): req.return_value.request = PreparedRequest() req.return_value._content = space.Space.to_json(space.Space()) - request = space.GetSpaceRequest() + request = space_setup.SetUpSpaceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -15512,7 +17198,7 @@ def test_get_space_rest_interceptors(null_interceptor): pre.return_value = request, metadata post.return_value = space.Space() - client.get_space( + client.set_up_space( request, metadata=[ ("key", "val"), @@ -15524,8 +17210,8 @@ def test_get_space_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_space_rest_bad_request( - transport: str = "rest", request_type=space.GetSpaceRequest +def test_set_up_space_rest_bad_request( + transport: str = "rest", request_type=space_setup.SetUpSpaceRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -15533,7 +17219,7 @@ def test_get_space_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15545,65 +17231,10 @@ def test_get_space_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_space(request) - - -def test_get_space_rest_flattened(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = space.Space() - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "spaces/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = space.Space.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.get_space(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=spaces/*}" % client.transport._host, args[1] - ) - - -def test_get_space_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.get_space( - space.GetSpaceRequest(), - name="name_value", - ) + client.set_up_space(request) -def test_get_space_rest_error(): +def test_set_up_space_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -15612,20 +17243,20 @@ def test_get_space_rest_error(): @pytest.mark.parametrize( "request_type", [ - gc_space.CreateSpaceRequest, + gc_space.UpdateSpaceRequest, dict, ], ) -def test_create_space_rest(request_type): +def test_update_space_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"space": {"name": "spaces/sample1"}} request_init["space"] = { - "name": "name_value", + "name": "spaces/sample1", "type_": 1, "space_type": 1, "single_user_bot_dm": True, @@ -15649,7 +17280,7 @@ def test_create_space_rest(request_type): # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = gc_space.CreateSpaceRequest.meta.fields["space"] + test_field = gc_space.UpdateSpaceRequest.meta.fields["space"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -15740,7 +17371,7 @@ def get_message_fields(field): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_space(request) + response = client.update_space(request) # Establish that the response is the type that we expect. assert isinstance(response, gc_space.Space) @@ -15761,7 +17392,7 @@ def get_message_fields(field): assert response.space_uri == "space_uri_value" -def test_create_space_rest_use_cached_wrapped_rpc(): +def test_update_space_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -15775,29 +17406,29 @@ def test_create_space_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_space in client._transport._wrapped_methods + assert client._transport.update_space in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.create_space] = mock_rpc + client._transport._wrapped_methods[client._transport.update_space] = mock_rpc request = {} - client.create_space(request) + client.update_space(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_space(request) + client.update_space(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_space_rest_required_fields(request_type=gc_space.CreateSpaceRequest): +def test_update_space_rest_required_fields(request_type=gc_space.UpdateSpaceRequest): transport_class = transports.ChatServiceRestTransport request_init = {} @@ -15811,16 +17442,16 @@ def test_create_space_rest_required_fields(request_type=gc_space.CreateSpaceRequ unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_space._get_unset_required_fields(jsonified_request) + ).update_space._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_space._get_unset_required_fields(jsonified_request) + ).update_space._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("request_id",)) + assert not set(unset_fields) - set(("update_mask",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -15844,7 +17475,7 @@ def test_create_space_rest_required_fields(request_type=gc_space.CreateSpaceRequ pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -15860,24 +17491,24 @@ def test_create_space_rest_required_fields(request_type=gc_space.CreateSpaceRequ response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_space(request) + response = client.update_space(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_space_rest_unset_required_fields(): +def test_update_space_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_space._get_unset_required_fields({}) - assert set(unset_fields) == (set(("requestId",)) & set(("space",))) + unset_fields = transport.update_space._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("space",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_space_rest_interceptors(null_interceptor): +def test_update_space_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15890,13 +17521,13 @@ def test_create_space_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_create_space" + transports.ChatServiceRestInterceptor, "post_update_space" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_create_space" + transports.ChatServiceRestInterceptor, "pre_update_space" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = gc_space.CreateSpaceRequest.pb(gc_space.CreateSpaceRequest()) + pb_message = gc_space.UpdateSpaceRequest.pb(gc_space.UpdateSpaceRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -15909,7 +17540,7 @@ def test_create_space_rest_interceptors(null_interceptor): req.return_value.request = PreparedRequest() req.return_value._content = gc_space.Space.to_json(gc_space.Space()) - request = gc_space.CreateSpaceRequest() + request = gc_space.UpdateSpaceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -15917,7 +17548,7 @@ def test_create_space_rest_interceptors(null_interceptor): pre.return_value = request, metadata post.return_value = gc_space.Space() - client.create_space( + client.update_space( request, metadata=[ ("key", "val"), @@ -15929,8 +17560,8 @@ def test_create_space_rest_interceptors(null_interceptor): post.assert_called_once() -def test_create_space_rest_bad_request( - transport: str = "rest", request_type=gc_space.CreateSpaceRequest +def test_update_space_rest_bad_request( + transport: str = "rest", request_type=gc_space.UpdateSpaceRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -15938,7 +17569,7 @@ def test_create_space_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"space": {"name": "spaces/sample1"}} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15950,10 +17581,10 @@ def test_create_space_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.create_space(request) + client.update_space(request) -def test_create_space_rest_flattened(): +def test_update_space_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -15965,11 +17596,12 @@ def test_create_space_rest_flattened(): return_value = gc_space.Space() # get arguments that satisfy an http rule for this method - sample_request = {} + sample_request = {"space": {"name": "spaces/sample1"}} # get truthy value for each flattened field mock_args = dict( space=gc_space.Space(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -15982,16 +17614,18 @@ def test_create_space_rest_flattened(): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.create_space(**mock_args) + client.update_space(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] - assert path_template.validate("%s/v1/spaces" % client.transport._host, args[1]) + assert path_template.validate( + "%s/v1/{space.name=spaces/*}" % client.transport._host, args[1] + ) -def test_create_space_rest_flattened_error(transport: str = "rest"): +def test_update_space_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -16000,13 +17634,14 @@ def test_create_space_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_space( - gc_space.CreateSpaceRequest(), + client.update_space( + gc_space.UpdateSpaceRequest(), space=gc_space.Space(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_create_space_rest_error(): +def test_update_space_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -16015,69 +17650,39 @@ def test_create_space_rest_error(): @pytest.mark.parametrize( "request_type", [ - space_setup.SetUpSpaceRequest, + space.DeleteSpaceRequest, dict, ], ) -def test_set_up_space_rest(request_type): +def test_delete_space_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"name": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = space.Space( - name="name_value", - type_=space.Space.Type.ROOM, - space_type=space.Space.SpaceType.SPACE, - single_user_bot_dm=True, - threaded=True, - display_name="display_name_value", - external_user_allowed=True, - space_threading_state=space.Space.SpaceThreadingState.THREADED_MESSAGES, - space_history_state=history_state.HistoryState.HISTORY_OFF, - import_mode=True, - admin_installed=True, - space_uri="space_uri_value", - ) + return_value = None # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = space.Space.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.set_up_space(request) + response = client.delete_space(request) # Establish that the response is the type that we expect. - assert isinstance(response, space.Space) - assert response.name == "name_value" - assert response.type_ == space.Space.Type.ROOM - assert response.space_type == space.Space.SpaceType.SPACE - assert response.single_user_bot_dm is True - assert response.threaded is True - assert response.display_name == "display_name_value" - assert response.external_user_allowed is True - assert ( - response.space_threading_state - == space.Space.SpaceThreadingState.THREADED_MESSAGES - ) - assert response.space_history_state == history_state.HistoryState.HISTORY_OFF - assert response.import_mode is True - assert response.admin_installed is True - assert response.space_uri == "space_uri_value" + assert response is None -def test_set_up_space_rest_use_cached_wrapped_rpc(): +def test_delete_space_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -16091,32 +17696,33 @@ def test_set_up_space_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.set_up_space in client._transport._wrapped_methods + assert client._transport.delete_space in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.set_up_space] = mock_rpc + client._transport._wrapped_methods[client._transport.delete_space] = mock_rpc request = {} - client.set_up_space(request) + client.delete_space(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.set_up_space(request) + client.delete_space(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_set_up_space_rest_required_fields(request_type=space_setup.SetUpSpaceRequest): +def test_delete_space_rest_required_fields(request_type=space.DeleteSpaceRequest): transport_class = transports.ChatServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -16127,17 +17733,21 @@ def test_set_up_space_rest_required_fields(request_type=space_setup.SetUpSpaceRe unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).set_up_space._get_unset_required_fields(jsonified_request) + ).delete_space._get_unset_required_fields(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() - ).set_up_space._get_unset_required_fields(jsonified_request) + ).delete_space._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" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16146,7 +17756,7 @@ def test_set_up_space_rest_required_fields(request_type=space_setup.SetUpSpaceRe request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = space.Space() + return_value = None # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -16158,40 +17768,36 @@ def test_set_up_space_rest_required_fields(request_type=space_setup.SetUpSpaceRe pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = space.Space.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.set_up_space(request) + response = client.delete_space(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_set_up_space_rest_unset_required_fields(): +def test_delete_space_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.set_up_space._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("space",))) + unset_fields = transport.delete_space._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_set_up_space_rest_interceptors(null_interceptor): +def test_delete_space_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16204,13 +17810,10 @@ def test_set_up_space_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_set_up_space" - ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_set_up_space" + transports.ChatServiceRestInterceptor, "pre_delete_space" ) as pre: pre.assert_not_called() - post.assert_not_called() - pb_message = space_setup.SetUpSpaceRequest.pb(space_setup.SetUpSpaceRequest()) + pb_message = space.DeleteSpaceRequest.pb(space.DeleteSpaceRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -16221,17 +17824,15 @@ def test_set_up_space_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = space.Space.to_json(space.Space()) - request = space_setup.SetUpSpaceRequest() + request = space.DeleteSpaceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = space.Space() - client.set_up_space( + client.delete_space( request, metadata=[ ("key", "val"), @@ -16240,11 +17841,10 @@ def test_set_up_space_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() -def test_set_up_space_rest_bad_request( - transport: str = "rest", request_type=space_setup.SetUpSpaceRequest +def test_delete_space_rest_bad_request( + transport: str = "rest", request_type=space.DeleteSpaceRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16252,7 +17852,7 @@ def test_set_up_space_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"name": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16264,168 +17864,106 @@ def test_set_up_space_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.set_up_space(request) - - -def test_set_up_space_rest_error(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + client.delete_space(request) -@pytest.mark.parametrize( - "request_type", - [ - gc_space.UpdateSpaceRequest, - dict, - ], -) -def test_update_space_rest(request_type): +def test_delete_space_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) - # send a request that will satisfy transcoding - request_init = {"space": {"name": "spaces/sample1"}} - request_init["space"] = { - "name": "spaces/sample1", - "type_": 1, - "space_type": 1, - "single_user_bot_dm": True, - "threaded": True, - "display_name": "display_name_value", - "external_user_allowed": True, - "space_threading_state": 2, - "space_details": { - "description": "description_value", - "guidelines": "guidelines_value", - }, - "space_history_state": 1, - "import_mode": True, - "create_time": {"seconds": 751, "nanos": 543}, - "admin_installed": True, - "access_settings": {"access_state": 1, "audience": "audience_value"}, - "space_uri": "space_uri_value", - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None - # Determine if the message type is proto-plus or protobuf - test_field = gc_space.UpdateSpaceRequest.meta.fields["space"] + # get arguments that satisfy an http rule for this method + sample_request = {"name": "spaces/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.delete_space(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=spaces/*}" % client.transport._host, args[1] + ) - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") +def test_delete_space_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_space( + space.DeleteSpaceRequest(), + name="name_value", + ) - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] - subfields_not_in_runtime = [] +def test_delete_space_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["space"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) +@pytest.mark.parametrize( + "request_type", + [ + space.CompleteImportSpaceRequest, + dict, + ], +) +def test_complete_import_space_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["space"][field])): - del request_init["space"][field][i][subfield] - else: - del request_init["space"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_space.Space( - name="name_value", - type_=gc_space.Space.Type.ROOM, - space_type=gc_space.Space.SpaceType.SPACE, - single_user_bot_dm=True, - threaded=True, - display_name="display_name_value", - external_user_allowed=True, - space_threading_state=gc_space.Space.SpaceThreadingState.THREADED_MESSAGES, - space_history_state=history_state.HistoryState.HISTORY_OFF, - import_mode=True, - admin_installed=True, - space_uri="space_uri_value", - ) + return_value = space.CompleteImportSpaceResponse() # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_space.Space.pb(return_value) + return_value = space.CompleteImportSpaceResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_space(request) + response = client.complete_import_space(request) # Establish that the response is the type that we expect. - assert isinstance(response, gc_space.Space) - assert response.name == "name_value" - assert response.type_ == gc_space.Space.Type.ROOM - assert response.space_type == gc_space.Space.SpaceType.SPACE - assert response.single_user_bot_dm is True - assert response.threaded is True - assert response.display_name == "display_name_value" - assert response.external_user_allowed is True - assert ( - response.space_threading_state - == gc_space.Space.SpaceThreadingState.THREADED_MESSAGES - ) - assert response.space_history_state == history_state.HistoryState.HISTORY_OFF - assert response.import_mode is True - assert response.admin_installed is True - assert response.space_uri == "space_uri_value" + assert isinstance(response, space.CompleteImportSpaceResponse) -def test_update_space_rest_use_cached_wrapped_rpc(): +def test_complete_import_space_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -16439,32 +17977,40 @@ def test_update_space_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_space in client._transport._wrapped_methods + assert ( + client._transport.complete_import_space + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.update_space] = mock_rpc + client._transport._wrapped_methods[ + client._transport.complete_import_space + ] = mock_rpc request = {} - client.update_space(request) + client.complete_import_space(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_space(request) + client.complete_import_space(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_space_rest_required_fields(request_type=gc_space.UpdateSpaceRequest): +def test_complete_import_space_rest_required_fields( + request_type=space.CompleteImportSpaceRequest, +): transport_class = transports.ChatServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -16475,19 +18021,21 @@ def test_update_space_rest_required_fields(request_type=gc_space.UpdateSpaceRequ unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_space._get_unset_required_fields(jsonified_request) + ).complete_import_space._get_unset_required_fields(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() - ).update_space._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",)) + ).complete_import_space._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" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16496,7 +18044,7 @@ def test_update_space_rest_required_fields(request_type=gc_space.UpdateSpaceRequ request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gc_space.Space() + return_value = space.CompleteImportSpaceResponse() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -16508,7 +18056,7 @@ def test_update_space_rest_required_fields(request_type=gc_space.UpdateSpaceRequ pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "post", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -16518,30 +18066,30 @@ def test_update_space_rest_required_fields(request_type=gc_space.UpdateSpaceRequ response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_space.Space.pb(return_value) + return_value = space.CompleteImportSpaceResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_space(request) + response = client.complete_import_space(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_space_rest_unset_required_fields(): +def test_complete_import_space_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_space._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("space",))) + unset_fields = transport.complete_import_space._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_space_rest_interceptors(null_interceptor): +def test_complete_import_space_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16554,13 +18102,15 @@ def test_update_space_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_update_space" + transports.ChatServiceRestInterceptor, "post_complete_import_space" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_update_space" + transports.ChatServiceRestInterceptor, "pre_complete_import_space" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = gc_space.UpdateSpaceRequest.pb(gc_space.UpdateSpaceRequest()) + pb_message = space.CompleteImportSpaceRequest.pb( + space.CompleteImportSpaceRequest() + ) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -16571,17 +18121,19 @@ def test_update_space_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gc_space.Space.to_json(gc_space.Space()) + req.return_value._content = space.CompleteImportSpaceResponse.to_json( + space.CompleteImportSpaceResponse() + ) - request = gc_space.UpdateSpaceRequest() + request = space.CompleteImportSpaceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gc_space.Space() + post.return_value = space.CompleteImportSpaceResponse() - client.update_space( + client.complete_import_space( request, metadata=[ ("key", "val"), @@ -16593,8 +18145,8 @@ def test_update_space_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_space_rest_bad_request( - transport: str = "rest", request_type=gc_space.UpdateSpaceRequest +def test_complete_import_space_rest_bad_request( + transport: str = "rest", request_type=space.CompleteImportSpaceRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16602,7 +18154,7 @@ def test_update_space_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"space": {"name": "spaces/sample1"}} + request_init = {"name": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16610,71 +18162,14 @@ def test_update_space_rest_bad_request( core_exceptions.BadRequest ): # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 400 - response_value.request = Request() - req.return_value = response_value - client.update_space(request) - - -def test_update_space_rest_flattened(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = gc_space.Space() - - # get arguments that satisfy an http rule for this method - sample_request = {"space": {"name": "spaces/sample1"}} - - # get truthy value for each flattened field - mock_args = dict( - space=gc_space.Space(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gc_space.Space.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.update_space(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{space.name=spaces/*}" % client.transport._host, args[1] - ) - - -def test_update_space_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.update_space( - gc_space.UpdateSpaceRequest(), - space=gc_space.Space(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.complete_import_space(request) -def test_update_space_rest_error(): +def test_complete_import_space_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -16683,39 +18178,69 @@ def test_update_space_rest_error(): @pytest.mark.parametrize( "request_type", [ - space.DeleteSpaceRequest, + space.FindDirectMessageRequest, dict, ], ) -def test_delete_space_rest(request_type): +def test_find_direct_message_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = space.Space( + name="name_value", + type_=space.Space.Type.ROOM, + space_type=space.Space.SpaceType.SPACE, + single_user_bot_dm=True, + threaded=True, + display_name="display_name_value", + external_user_allowed=True, + space_threading_state=space.Space.SpaceThreadingState.THREADED_MESSAGES, + space_history_state=history_state.HistoryState.HISTORY_OFF, + import_mode=True, + admin_installed=True, + space_uri="space_uri_value", + ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + # Convert return value to protobuf type + return_value = space.Space.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_space(request) + response = client.find_direct_message(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, space.Space) + assert response.name == "name_value" + assert response.type_ == space.Space.Type.ROOM + assert response.space_type == space.Space.SpaceType.SPACE + assert response.single_user_bot_dm is True + assert response.threaded is True + assert response.display_name == "display_name_value" + assert response.external_user_allowed is True + assert ( + response.space_threading_state + == space.Space.SpaceThreadingState.THREADED_MESSAGES + ) + assert response.space_history_state == history_state.HistoryState.HISTORY_OFF + assert response.import_mode is True + assert response.admin_installed is True + assert response.space_uri == "space_uri_value" -def test_delete_space_rest_use_cached_wrapped_rpc(): +def test_find_direct_message_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -16729,29 +18254,35 @@ def test_delete_space_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_space in client._transport._wrapped_methods + assert ( + client._transport.find_direct_message in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.delete_space] = mock_rpc + client._transport._wrapped_methods[ + client._transport.find_direct_message + ] = mock_rpc request = {} - client.delete_space(request) + client.find_direct_message(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_space(request) + client.find_direct_message(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_space_rest_required_fields(request_type=space.DeleteSpaceRequest): +def test_find_direct_message_rest_required_fields( + request_type=space.FindDirectMessageRequest, +): transport_class = transports.ChatServiceRestTransport request_init = {} @@ -16763,19 +18294,24 @@ def test_delete_space_rest_required_fields(request_type=space.DeleteSpaceRequest ) # verify fields with default values are dropped + assert "name" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_space._get_unset_required_fields(jsonified_request) + ).find_direct_message._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "name" in jsonified_request + assert jsonified_request["name"] == request_init["name"] jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_space._get_unset_required_fields(jsonified_request) + ).find_direct_message._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("name",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -16789,7 +18325,7 @@ def test_delete_space_rest_required_fields(request_type=space.DeleteSpaceRequest request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = space.Space() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -16801,36 +18337,45 @@ def test_delete_space_rest_required_fields(request_type=space.DeleteSpaceRequest pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "get", "query_params": pb_request, } transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = space.Space.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_space(request) + response = client.find_direct_message(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "name", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_space_rest_unset_required_fields(): +def test_find_direct_message_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_space._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.find_direct_message._get_unset_required_fields({}) + assert set(unset_fields) == (set(("name",)) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_space_rest_interceptors(null_interceptor): +def test_find_direct_message_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16843,10 +18388,13 @@ def test_delete_space_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_delete_space" + transports.ChatServiceRestInterceptor, "post_find_direct_message" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_find_direct_message" ) as pre: pre.assert_not_called() - pb_message = space.DeleteSpaceRequest.pb(space.DeleteSpaceRequest()) + post.assert_not_called() + pb_message = space.FindDirectMessageRequest.pb(space.FindDirectMessageRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -16857,15 +18405,17 @@ def test_delete_space_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() + req.return_value._content = space.Space.to_json(space.Space()) - request = space.DeleteSpaceRequest() + request = space.FindDirectMessageRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = space.Space() - client.delete_space( + client.find_direct_message( request, metadata=[ ("key", "val"), @@ -16874,10 +18424,11 @@ def test_delete_space_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() -def test_delete_space_rest_bad_request( - transport: str = "rest", request_type=space.DeleteSpaceRequest +def test_find_direct_message_rest_bad_request( + transport: str = "rest", request_type=space.FindDirectMessageRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -16885,7 +18436,7 @@ def test_delete_space_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16897,63 +18448,10 @@ def test_delete_space_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.delete_space(request) - - -def test_delete_space_rest_flattened(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "spaces/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.delete_space(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=spaces/*}" % client.transport._host, args[1] - ) - - -def test_delete_space_rest_flattened_error(transport: str = "rest"): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.delete_space( - space.DeleteSpaceRequest(), - name="name_value", - ) + client.find_direct_message(request) -def test_delete_space_rest_error(): +def test_find_direct_message_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -16962,41 +18460,130 @@ def test_delete_space_rest_error(): @pytest.mark.parametrize( "request_type", [ - space.CompleteImportSpaceRequest, + gc_membership.CreateMembershipRequest, dict, ], ) -def test_complete_import_space_rest(request_type): +def test_create_membership_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) - # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1"} + # send a request that will satisfy transcoding + request_init = {"parent": "spaces/sample1"} + request_init["membership"] = { + "name": "name_value", + "state": 1, + "role": 1, + "member": { + "name": "name_value", + "display_name": "display_name_value", + "domain_id": "domain_id_value", + "type_": 1, + "is_anonymous": True, + }, + "group_member": {"name": "name_value"}, + "create_time": {"seconds": 751, "nanos": 543}, + "delete_time": {}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = gc_membership.CreateMembershipRequest.meta.fields["membership"] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["membership"].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["membership"][field])): + del request_init["membership"][field][i][subfield] + else: + del request_init["membership"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = space.CompleteImportSpaceResponse() + return_value = gc_membership.Membership( + name="name_value", + state=gc_membership.Membership.MembershipState.JOINED, + role=gc_membership.Membership.MembershipRole.ROLE_MEMBER, + ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = space.CompleteImportSpaceResponse.pb(return_value) + return_value = gc_membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.complete_import_space(request) + response = client.create_membership(request) # Establish that the response is the type that we expect. - assert isinstance(response, space.CompleteImportSpaceResponse) + assert isinstance(response, gc_membership.Membership) + assert response.name == "name_value" + assert response.state == gc_membership.Membership.MembershipState.JOINED + assert response.role == gc_membership.Membership.MembershipRole.ROLE_MEMBER -def test_complete_import_space_rest_use_cached_wrapped_rpc(): +def test_create_membership_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -17010,10 +18597,7 @@ def test_complete_import_space_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.complete_import_space - in client._transport._wrapped_methods - ) + assert client._transport.create_membership in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -17021,29 +18605,29 @@ def test_complete_import_space_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.complete_import_space + client._transport.create_membership ] = mock_rpc request = {} - client.complete_import_space(request) + client.create_membership(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.complete_import_space(request) + client.create_membership(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_complete_import_space_rest_required_fields( - request_type=space.CompleteImportSpaceRequest, +def test_create_membership_rest_required_fields( + request_type=gc_membership.CreateMembershipRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -17054,21 +18638,21 @@ def test_complete_import_space_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).complete_import_space._get_unset_required_fields(jsonified_request) + ).create_membership._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).complete_import_space._get_unset_required_fields(jsonified_request) + ).create_membership._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" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17077,7 +18661,7 @@ def test_complete_import_space_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = space.CompleteImportSpaceResponse() + return_value = gc_membership.Membership() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -17099,30 +18683,38 @@ def test_complete_import_space_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = space.CompleteImportSpaceResponse.pb(return_value) + return_value = gc_membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.complete_import_space(request) + response = client.create_membership(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_complete_import_space_rest_unset_required_fields(): +def test_create_membership_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.complete_import_space._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_membership._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "membership", + ) + ) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_complete_import_space_rest_interceptors(null_interceptor): +def test_create_membership_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17135,14 +18727,14 @@ def test_complete_import_space_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_complete_import_space" + transports.ChatServiceRestInterceptor, "post_create_membership" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_complete_import_space" + transports.ChatServiceRestInterceptor, "pre_create_membership" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = space.CompleteImportSpaceRequest.pb( - space.CompleteImportSpaceRequest() + pb_message = gc_membership.CreateMembershipRequest.pb( + gc_membership.CreateMembershipRequest() ) transcode.return_value = { "method": "post", @@ -17154,19 +18746,19 @@ def test_complete_import_space_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = space.CompleteImportSpaceResponse.to_json( - space.CompleteImportSpaceResponse() + req.return_value._content = gc_membership.Membership.to_json( + gc_membership.Membership() ) - request = space.CompleteImportSpaceRequest() + request = gc_membership.CreateMembershipRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = space.CompleteImportSpaceResponse() + post.return_value = gc_membership.Membership() - client.complete_import_space( + client.create_membership( request, metadata=[ ("key", "val"), @@ -17178,8 +18770,8 @@ def test_complete_import_space_rest_interceptors(null_interceptor): post.assert_called_once() -def test_complete_import_space_rest_bad_request( - transport: str = "rest", request_type=space.CompleteImportSpaceRequest +def test_create_membership_rest_bad_request( + transport: str = "rest", request_type=gc_membership.CreateMembershipRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17187,7 +18779,7 @@ def test_complete_import_space_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1"} + request_init = {"parent": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17199,10 +18791,67 @@ def test_complete_import_space_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.complete_import_space(request) + client.create_membership(request) -def test_complete_import_space_rest_error(): +def test_create_membership_rest_flattened(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_membership.Membership() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "spaces/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + membership=gc_membership.Membership(name="name_value"), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_membership.Membership.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_membership(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=spaces/*}/members" % client.transport._host, args[1] + ) + + +def test_create_membership_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_membership( + gc_membership.CreateMembershipRequest(), + parent="parent_value", + membership=gc_membership.Membership(name="name_value"), + ) + + +def test_create_membership_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -17211,69 +18860,130 @@ def test_complete_import_space_rest_error(): @pytest.mark.parametrize( "request_type", [ - space.FindDirectMessageRequest, + gc_membership.UpdateMembershipRequest, dict, ], ) -def test_find_direct_message_rest(request_type): +def test_update_membership_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"membership": {"name": "spaces/sample1/members/sample2"}} + request_init["membership"] = { + "name": "spaces/sample1/members/sample2", + "state": 1, + "role": 1, + "member": { + "name": "name_value", + "display_name": "display_name_value", + "domain_id": "domain_id_value", + "type_": 1, + "is_anonymous": True, + }, + "group_member": {"name": "name_value"}, + "create_time": {"seconds": 751, "nanos": 543}, + "delete_time": {}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = gc_membership.UpdateMembershipRequest.meta.fields["membership"] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["membership"].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["membership"][field])): + del request_init["membership"][field][i][subfield] + else: + del request_init["membership"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = space.Space( + return_value = gc_membership.Membership( name="name_value", - type_=space.Space.Type.ROOM, - space_type=space.Space.SpaceType.SPACE, - single_user_bot_dm=True, - threaded=True, - display_name="display_name_value", - external_user_allowed=True, - space_threading_state=space.Space.SpaceThreadingState.THREADED_MESSAGES, - space_history_state=history_state.HistoryState.HISTORY_OFF, - import_mode=True, - admin_installed=True, - space_uri="space_uri_value", + state=gc_membership.Membership.MembershipState.JOINED, + role=gc_membership.Membership.MembershipRole.ROLE_MEMBER, ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = space.Space.pb(return_value) + return_value = gc_membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.find_direct_message(request) + response = client.update_membership(request) # Establish that the response is the type that we expect. - assert isinstance(response, space.Space) + assert isinstance(response, gc_membership.Membership) assert response.name == "name_value" - assert response.type_ == space.Space.Type.ROOM - assert response.space_type == space.Space.SpaceType.SPACE - assert response.single_user_bot_dm is True - assert response.threaded is True - assert response.display_name == "display_name_value" - assert response.external_user_allowed is True - assert ( - response.space_threading_state - == space.Space.SpaceThreadingState.THREADED_MESSAGES - ) - assert response.space_history_state == history_state.HistoryState.HISTORY_OFF - assert response.import_mode is True - assert response.admin_installed is True - assert response.space_uri == "space_uri_value" + assert response.state == gc_membership.Membership.MembershipState.JOINED + assert response.role == gc_membership.Membership.MembershipRole.ROLE_MEMBER -def test_find_direct_message_rest_use_cached_wrapped_rpc(): +def test_update_membership_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -17287,9 +18997,7 @@ def test_find_direct_message_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.find_direct_message in client._transport._wrapped_methods - ) + assert client._transport.update_membership in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -17297,29 +19005,28 @@ def test_find_direct_message_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.find_direct_message + client._transport.update_membership ] = mock_rpc request = {} - client.find_direct_message(request) + client.update_membership(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.find_direct_message(request) + client.update_membership(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_find_direct_message_rest_required_fields( - request_type=space.FindDirectMessageRequest, +def test_update_membership_rest_required_fields( + request_type=gc_membership.UpdateMembershipRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -17327,29 +19034,22 @@ def test_find_direct_message_rest_required_fields( ) # verify fields with default values are dropped - assert "name" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).find_direct_message._get_unset_required_fields(jsonified_request) + ).update_membership._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "name" in jsonified_request - assert jsonified_request["name"] == request_init["name"] - - jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).find_direct_message._get_unset_required_fields(jsonified_request) + ).update_membership._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("name",)) + assert not set(unset_fields) - set(("update_mask",)) 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" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17358,7 +19058,7 @@ def test_find_direct_message_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = space.Space() + return_value = gc_membership.Membership() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -17370,45 +19070,48 @@ def test_find_direct_message_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "patch", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = space.Space.pb(return_value) + return_value = gc_membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.find_direct_message(request) + response = client.update_membership(request) - expected_params = [ - ( - "name", - "", - ), - ("$alt", "json;enum-encoding=int"), - ] + expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_find_direct_message_rest_unset_required_fields(): +def test_update_membership_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.find_direct_message._get_unset_required_fields({}) - assert set(unset_fields) == (set(("name",)) & set(("name",))) + unset_fields = transport.update_membership._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "membership", + "updateMask", + ) + ) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_find_direct_message_rest_interceptors(null_interceptor): +def test_update_membership_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17421,13 +19124,15 @@ def test_find_direct_message_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_find_direct_message" + transports.ChatServiceRestInterceptor, "post_update_membership" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_find_direct_message" + transports.ChatServiceRestInterceptor, "pre_update_membership" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = space.FindDirectMessageRequest.pb(space.FindDirectMessageRequest()) + pb_message = gc_membership.UpdateMembershipRequest.pb( + gc_membership.UpdateMembershipRequest() + ) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -17438,17 +19143,19 @@ def test_find_direct_message_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = space.Space.to_json(space.Space()) + req.return_value._content = gc_membership.Membership.to_json( + gc_membership.Membership() + ) - request = space.FindDirectMessageRequest() + request = gc_membership.UpdateMembershipRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = space.Space() + post.return_value = gc_membership.Membership() - client.find_direct_message( + client.update_membership( request, metadata=[ ("key", "val"), @@ -17460,8 +19167,8 @@ def test_find_direct_message_rest_interceptors(null_interceptor): post.assert_called_once() -def test_find_direct_message_rest_bad_request( - transport: str = "rest", request_type=space.FindDirectMessageRequest +def test_update_membership_rest_bad_request( + transport: str = "rest", request_type=gc_membership.UpdateMembershipRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17469,7 +19176,7 @@ def test_find_direct_message_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"membership": {"name": "spaces/sample1/members/sample2"}} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17481,142 +19188,118 @@ def test_find_direct_message_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.find_direct_message(request) - - -def test_find_direct_message_rest_error(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + client.update_membership(request) -@pytest.mark.parametrize( - "request_type", - [ - gc_membership.CreateMembershipRequest, - dict, - ], -) -def test_create_membership_rest(request_type): +def test_update_membership_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} - request_init["membership"] = { - "name": "name_value", - "state": 1, - "role": 1, - "member": { - "name": "name_value", - "display_name": "display_name_value", - "domain_id": "domain_id_value", - "type_": 1, - "is_anonymous": True, - }, - "group_member": {"name": "name_value"}, - "create_time": {"seconds": 751, "nanos": 543}, - "delete_time": {}, - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gc_membership.Membership() - # Determine if the message type is proto-plus or protobuf - test_field = gc_membership.CreateMembershipRequest.meta.fields["membership"] + # get arguments that satisfy an http rule for this method + sample_request = {"membership": {"name": "spaces/sample1/members/sample2"}} - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] + # get truthy value for each flattened field + mock_args = dict( + membership=gc_membership.Membership(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gc_membership.Membership.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields + client.update_membership(**mock_args) - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{membership.name=spaces/*/members/*}" % client.transport._host, + args[1], + ) - subfields_not_in_runtime = [] - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["membership"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value +def test_update_membership_rest_flattened_error(transport: str = "rest"): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_membership( + gc_membership.UpdateMembershipRequest(), + membership=gc_membership.Membership(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_update_membership_rest_error(): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + membership.DeleteMembershipRequest, + dict, + ], +) +def test_delete_membership_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["membership"][field])): - del request_init["membership"][field][i][subfield] - else: - del request_init["membership"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/members/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_membership.Membership( + return_value = membership.Membership( name="name_value", - state=gc_membership.Membership.MembershipState.JOINED, - role=gc_membership.Membership.MembershipRole.ROLE_MEMBER, + state=membership.Membership.MembershipState.JOINED, + role=membership.Membership.MembershipRole.ROLE_MEMBER, ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_membership.Membership.pb(return_value) + return_value = membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_membership(request) + response = client.delete_membership(request) # Establish that the response is the type that we expect. - assert isinstance(response, gc_membership.Membership) + assert isinstance(response, membership.Membership) assert response.name == "name_value" - assert response.state == gc_membership.Membership.MembershipState.JOINED - assert response.role == gc_membership.Membership.MembershipRole.ROLE_MEMBER + assert response.state == membership.Membership.MembershipState.JOINED + assert response.role == membership.Membership.MembershipRole.ROLE_MEMBER -def test_create_membership_rest_use_cached_wrapped_rpc(): +def test_delete_membership_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -17630,7 +19313,7 @@ def test_create_membership_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_membership in client._transport._wrapped_methods + assert client._transport.delete_membership in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -17638,29 +19321,29 @@ def test_create_membership_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_membership + client._transport.delete_membership ] = mock_rpc request = {} - client.create_membership(request) + client.delete_membership(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_membership(request) + client.delete_membership(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_membership_rest_required_fields( - request_type=gc_membership.CreateMembershipRequest, +def test_delete_membership_rest_required_fields( + request_type=membership.DeleteMembershipRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -17671,21 +19354,21 @@ def test_create_membership_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_membership._get_unset_required_fields(jsonified_request) + ).delete_membership._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_membership._get_unset_required_fields(jsonified_request) + ).delete_membership._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" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17694,7 +19377,7 @@ def test_create_membership_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gc_membership.Membership() + return_value = membership.Membership() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -17706,48 +19389,39 @@ def test_create_membership_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_membership.Membership.pb(return_value) + return_value = membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_membership(request) + response = client.delete_membership(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_membership_rest_unset_required_fields(): +def test_delete_membership_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_membership._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "membership", - ) - ) - ) + unset_fields = transport.delete_membership._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_membership_rest_interceptors(null_interceptor): +def test_delete_membership_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17760,14 +19434,14 @@ def test_create_membership_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_create_membership" + transports.ChatServiceRestInterceptor, "post_delete_membership" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_create_membership" + transports.ChatServiceRestInterceptor, "pre_delete_membership" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = gc_membership.CreateMembershipRequest.pb( - gc_membership.CreateMembershipRequest() + pb_message = membership.DeleteMembershipRequest.pb( + membership.DeleteMembershipRequest() ) transcode.return_value = { "method": "post", @@ -17779,19 +19453,19 @@ def test_create_membership_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gc_membership.Membership.to_json( - gc_membership.Membership() + req.return_value._content = membership.Membership.to_json( + membership.Membership() ) - request = gc_membership.CreateMembershipRequest() + request = membership.DeleteMembershipRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gc_membership.Membership() + post.return_value = membership.Membership() - client.create_membership( + client.delete_membership( request, metadata=[ ("key", "val"), @@ -17803,8 +19477,8 @@ def test_create_membership_rest_interceptors(null_interceptor): post.assert_called_once() -def test_create_membership_rest_bad_request( - transport: str = "rest", request_type=gc_membership.CreateMembershipRequest +def test_delete_membership_rest_bad_request( + transport: str = "rest", request_type=membership.DeleteMembershipRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -17812,7 +19486,7 @@ def test_create_membership_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1"} + request_init = {"name": "spaces/sample1/members/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17824,10 +19498,10 @@ def test_create_membership_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.create_membership(request) + client.delete_membership(request) -def test_create_membership_rest_flattened(): +def test_delete_membership_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -17836,15 +19510,14 @@ def test_create_membership_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_membership.Membership() + return_value = membership.Membership() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "spaces/sample1"} + sample_request = {"name": "spaces/sample1/members/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - membership=gc_membership.Membership(name="name_value"), + name="name_value", ) mock_args.update(sample_request) @@ -17852,23 +19525,23 @@ def test_create_membership_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_membership.Membership.pb(return_value) + return_value = membership.Membership.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.create_membership(**mock_args) + client.delete_membership(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=spaces/*}/members" % client.transport._host, args[1] + "%s/v1/{name=spaces/*/members/*}" % client.transport._host, args[1] ) -def test_create_membership_rest_flattened_error(transport: str = "rest"): +def test_delete_membership_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -17877,14 +19550,13 @@ def test_create_membership_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_membership( - gc_membership.CreateMembershipRequest(), - parent="parent_value", - membership=gc_membership.Membership(name="name_value"), + client.delete_membership( + membership.DeleteMembershipRequest(), + name="name_value", ) -def test_create_membership_rest_error(): +def test_delete_membership_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -17893,39 +19565,35 @@ def test_create_membership_rest_error(): @pytest.mark.parametrize( "request_type", [ - gc_membership.UpdateMembershipRequest, + gc_reaction.CreateReactionRequest, dict, ], ) -def test_update_membership_rest(request_type): +def test_create_reaction_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"membership": {"name": "spaces/sample1/members/sample2"}} - request_init["membership"] = { - "name": "spaces/sample1/members/sample2", - "state": 1, - "role": 1, - "member": { + request_init = {"parent": "spaces/sample1/messages/sample2"} + request_init["reaction"] = { + "name": "name_value", + "user": { "name": "name_value", "display_name": "display_name_value", "domain_id": "domain_id_value", "type_": 1, "is_anonymous": True, }, - "group_member": {"name": "name_value"}, - "create_time": {"seconds": 751, "nanos": 543}, - "delete_time": {}, + "emoji": {"unicode": "unicode_value", "custom_emoji": {"uid": "uid_value"}}, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = gc_membership.UpdateMembershipRequest.meta.fields["membership"] + test_field = gc_reaction.CreateReactionRequest.meta.fields["reaction"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -17953,7 +19621,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["membership"].items(): # pragma: NO COVER + for field, value in request_init["reaction"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -17983,40 +19651,36 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["membership"][field])): - del request_init["membership"][field][i][subfield] + for i in range(0, len(request_init["reaction"][field])): + del request_init["reaction"][field][i][subfield] else: - del request_init["membership"][field][subfield] + del request_init["reaction"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_membership.Membership( + return_value = gc_reaction.Reaction( name="name_value", - state=gc_membership.Membership.MembershipState.JOINED, - role=gc_membership.Membership.MembershipRole.ROLE_MEMBER, ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_membership.Membership.pb(return_value) + return_value = gc_reaction.Reaction.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_membership(request) + response = client.create_reaction(request) # Establish that the response is the type that we expect. - assert isinstance(response, gc_membership.Membership) + assert isinstance(response, gc_reaction.Reaction) assert response.name == "name_value" - assert response.state == gc_membership.Membership.MembershipState.JOINED - assert response.role == gc_membership.Membership.MembershipRole.ROLE_MEMBER -def test_update_membership_rest_use_cached_wrapped_rpc(): +def test_create_reaction_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -18030,36 +19694,35 @@ def test_update_membership_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_membership in client._transport._wrapped_methods + assert client._transport.create_reaction in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[ - client._transport.update_membership - ] = mock_rpc + client._transport._wrapped_methods[client._transport.create_reaction] = mock_rpc request = {} - client.update_membership(request) + client.create_reaction(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_membership(request) + client.create_reaction(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_membership_rest_required_fields( - request_type=gc_membership.UpdateMembershipRequest, +def test_create_reaction_rest_required_fields( + request_type=gc_reaction.CreateReactionRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -18070,19 +19733,21 @@ def test_update_membership_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_membership._get_unset_required_fields(jsonified_request) + ).create_reaction._get_unset_required_fields(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() - ).update_membership._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",)) + ).create_reaction._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" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18091,7 +19756,7 @@ def test_update_membership_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gc_membership.Membership() + return_value = gc_reaction.Reaction() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -18103,7 +19768,7 @@ def test_update_membership_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "post", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -18113,38 +19778,38 @@ def test_update_membership_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_membership.Membership.pb(return_value) + return_value = gc_reaction.Reaction.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_membership(request) + response = client.create_reaction(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_membership_rest_unset_required_fields(): +def test_create_reaction_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_membership._get_unset_required_fields({}) + unset_fields = transport.create_reaction._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) + set(()) & set( ( - "membership", - "updateMask", + "parent", + "reaction", ) ) ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_membership_rest_interceptors(null_interceptor): +def test_create_reaction_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18157,14 +19822,14 @@ def test_update_membership_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_update_membership" + transports.ChatServiceRestInterceptor, "post_create_reaction" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_update_membership" + transports.ChatServiceRestInterceptor, "pre_create_reaction" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = gc_membership.UpdateMembershipRequest.pb( - gc_membership.UpdateMembershipRequest() + pb_message = gc_reaction.CreateReactionRequest.pb( + gc_reaction.CreateReactionRequest() ) transcode.return_value = { "method": "post", @@ -18176,19 +19841,17 @@ def test_update_membership_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gc_membership.Membership.to_json( - gc_membership.Membership() - ) + req.return_value._content = gc_reaction.Reaction.to_json(gc_reaction.Reaction()) - request = gc_membership.UpdateMembershipRequest() + request = gc_reaction.CreateReactionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gc_membership.Membership() + post.return_value = gc_reaction.Reaction() - client.update_membership( + client.create_reaction( request, metadata=[ ("key", "val"), @@ -18200,8 +19863,8 @@ def test_update_membership_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_membership_rest_bad_request( - transport: str = "rest", request_type=gc_membership.UpdateMembershipRequest +def test_create_reaction_rest_bad_request( + transport: str = "rest", request_type=gc_reaction.CreateReactionRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18209,7 +19872,7 @@ def test_update_membership_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"membership": {"name": "spaces/sample1/members/sample2"}} + request_init = {"parent": "spaces/sample1/messages/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -18221,10 +19884,10 @@ def test_update_membership_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.update_membership(request) + client.create_reaction(request) -def test_update_membership_rest_flattened(): +def test_create_reaction_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -18233,15 +19896,15 @@ def test_update_membership_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_membership.Membership() + return_value = gc_reaction.Reaction() # get arguments that satisfy an http rule for this method - sample_request = {"membership": {"name": "spaces/sample1/members/sample2"}} + sample_request = {"parent": "spaces/sample1/messages/sample2"} # get truthy value for each flattened field mock_args = dict( - membership=gc_membership.Membership(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", + reaction=gc_reaction.Reaction(name="name_value"), ) mock_args.update(sample_request) @@ -18249,24 +19912,24 @@ def test_update_membership_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_membership.Membership.pb(return_value) + return_value = gc_reaction.Reaction.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.update_membership(**mock_args) + client.create_reaction(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{membership.name=spaces/*/members/*}" % client.transport._host, + "%s/v1/{parent=spaces/*/messages/*}/reactions" % client.transport._host, args[1], ) -def test_update_membership_rest_flattened_error(transport: str = "rest"): +def test_create_reaction_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -18275,14 +19938,14 @@ def test_update_membership_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_membership( - gc_membership.UpdateMembershipRequest(), - membership=gc_membership.Membership(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.create_reaction( + gc_reaction.CreateReactionRequest(), + parent="parent_value", + reaction=gc_reaction.Reaction(name="name_value"), ) -def test_update_membership_rest_error(): +def test_create_reaction_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -18291,48 +19954,44 @@ def test_update_membership_rest_error(): @pytest.mark.parametrize( "request_type", [ - membership.DeleteMembershipRequest, + reaction.ListReactionsRequest, dict, ], ) -def test_delete_membership_rest(request_type): +def test_list_reactions_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/members/sample2"} + request_init = {"parent": "spaces/sample1/messages/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = membership.Membership( - name="name_value", - state=membership.Membership.MembershipState.JOINED, - role=membership.Membership.MembershipRole.ROLE_MEMBER, + return_value = reaction.ListReactionsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = membership.Membership.pb(return_value) + return_value = reaction.ListReactionsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_membership(request) + response = client.list_reactions(request) # Establish that the response is the type that we expect. - assert isinstance(response, membership.Membership) - assert response.name == "name_value" - assert response.state == membership.Membership.MembershipState.JOINED - assert response.role == membership.Membership.MembershipRole.ROLE_MEMBER + assert isinstance(response, pagers.ListReactionsPager) + assert response.next_page_token == "next_page_token_value" -def test_delete_membership_rest_use_cached_wrapped_rpc(): +def test_list_reactions_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -18346,37 +20005,35 @@ def test_delete_membership_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_membership in client._transport._wrapped_methods + assert client._transport.list_reactions in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[ - client._transport.delete_membership - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_reactions] = mock_rpc request = {} - client.delete_membership(request) + client.list_reactions(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_membership(request) + client.list_reactions(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_membership_rest_required_fields( - request_type=membership.DeleteMembershipRequest, +def test_list_reactions_rest_required_fields( + request_type=reaction.ListReactionsRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -18387,21 +20044,29 @@ def test_delete_membership_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_membership._get_unset_required_fields(jsonified_request) + ).list_reactions._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_membership._get_unset_required_fields(jsonified_request) + ).list_reactions._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) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18410,7 +20075,7 @@ def test_delete_membership_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = membership.Membership() + return_value = reaction.ListReactionsResponse() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -18422,7 +20087,7 @@ def test_delete_membership_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "get", "query_params": pb_request, } transcode.return_value = transcode_result @@ -18431,30 +20096,39 @@ def test_delete_membership_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = membership.Membership.pb(return_value) + return_value = reaction.ListReactionsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_membership(request) + response = client.list_reactions(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_membership_rest_unset_required_fields(): +def test_list_reactions_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_membership._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.list_reactions._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_membership_rest_interceptors(null_interceptor): +def test_list_reactions_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18467,15 +20141,13 @@ def test_delete_membership_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_delete_membership" + transports.ChatServiceRestInterceptor, "post_list_reactions" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_delete_membership" + transports.ChatServiceRestInterceptor, "pre_list_reactions" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = membership.DeleteMembershipRequest.pb( - membership.DeleteMembershipRequest() - ) + pb_message = reaction.ListReactionsRequest.pb(reaction.ListReactionsRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -18486,19 +20158,19 @@ def test_delete_membership_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = membership.Membership.to_json( - membership.Membership() + req.return_value._content = reaction.ListReactionsResponse.to_json( + reaction.ListReactionsResponse() ) - request = membership.DeleteMembershipRequest() + request = reaction.ListReactionsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = membership.Membership() + post.return_value = reaction.ListReactionsResponse() - client.delete_membership( + client.list_reactions( request, metadata=[ ("key", "val"), @@ -18510,8 +20182,8 @@ def test_delete_membership_rest_interceptors(null_interceptor): post.assert_called_once() -def test_delete_membership_rest_bad_request( - transport: str = "rest", request_type=membership.DeleteMembershipRequest +def test_list_reactions_rest_bad_request( + transport: str = "rest", request_type=reaction.ListReactionsRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18519,7 +20191,7 @@ def test_delete_membership_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/members/sample2"} + request_init = {"parent": "spaces/sample1/messages/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -18531,10 +20203,10 @@ def test_delete_membership_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.delete_membership(request) + client.list_reactions(request) -def test_delete_membership_rest_flattened(): +def test_list_reactions_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -18543,14 +20215,14 @@ def test_delete_membership_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = membership.Membership() + return_value = reaction.ListReactionsResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "spaces/sample1/members/sample2"} + sample_request = {"parent": "spaces/sample1/messages/sample2"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -18558,23 +20230,24 @@ def test_delete_membership_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = membership.Membership.pb(return_value) + return_value = reaction.ListReactionsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.delete_membership(**mock_args) + client.list_reactions(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=spaces/*/members/*}" % client.transport._host, args[1] + "%s/v1/{parent=spaces/*/messages/*}/reactions" % client.transport._host, + args[1], ) -def test_delete_membership_rest_flattened_error(transport: str = "rest"): +def test_list_reactions_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -18583,137 +20256,109 @@ def test_delete_membership_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_membership( - membership.DeleteMembershipRequest(), - name="name_value", + client.list_reactions( + reaction.ListReactionsRequest(), + parent="parent_value", ) -def test_delete_membership_rest_error(): - client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - -@pytest.mark.parametrize( - "request_type", - [ - gc_reaction.CreateReactionRequest, - dict, - ], -) -def test_create_reaction_rest(request_type): +def test_list_reactions_rest_pager(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1/messages/sample2"} - request_init["reaction"] = { - "name": "name_value", - "user": { - "name": "name_value", - "display_name": "display_name_value", - "domain_id": "domain_id_value", - "type_": 1, - "is_anonymous": True, - }, - "emoji": {"unicode": "unicode_value", "custom_emoji": {"uid": "uid_value"}}, - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = gc_reaction.CreateReactionRequest.meta.fields["reaction"] - - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + reaction.ListReactionsResponse( + reactions=[ + reaction.Reaction(), + reaction.Reaction(), + reaction.Reaction(), + ], + next_page_token="abc", + ), + reaction.ListReactionsResponse( + reactions=[], + next_page_token="def", + ), + reaction.ListReactionsResponse( + reactions=[ + reaction.Reaction(), + ], + next_page_token="ghi", + ), + reaction.ListReactionsResponse( + reactions=[ + reaction.Reaction(), + reaction.Reaction(), + ], + ), + ) + # Two responses for two calls + response = response + response - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + # Wrap the values into proper Response objs + response = tuple(reaction.ListReactionsResponse.to_json(x) for x in response) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields + sample_request = {"parent": "spaces/sample1/messages/sample2"} - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] + pager = client.list_reactions(request=sample_request) - subfields_not_in_runtime = [] + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, reaction.Reaction) for i in results) - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["reaction"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value + pages = list(client.list_reactions(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["reaction"][field])): - del request_init["reaction"][field][i][subfield] - else: - del request_init["reaction"][field][subfield] +@pytest.mark.parametrize( + "request_type", + [ + reaction.DeleteReactionRequest, + dict, + ], +) +def test_delete_reaction_rest(request_type): + client = ChatServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/messages/sample2/reactions/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_reaction.Reaction( - name="name_value", - ) + return_value = None # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gc_reaction.Reaction.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_reaction(request) + response = client.delete_reaction(request) # Establish that the response is the type that we expect. - assert isinstance(response, gc_reaction.Reaction) - assert response.name == "name_value" + assert response is None -def test_create_reaction_rest_use_cached_wrapped_rpc(): +def test_delete_reaction_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -18727,35 +20372,35 @@ def test_create_reaction_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_reaction in client._transport._wrapped_methods + assert client._transport.delete_reaction in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.create_reaction] = mock_rpc + client._transport._wrapped_methods[client._transport.delete_reaction] = mock_rpc request = {} - client.create_reaction(request) + client.delete_reaction(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_reaction(request) + client.delete_reaction(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_reaction_rest_required_fields( - request_type=gc_reaction.CreateReactionRequest, +def test_delete_reaction_rest_required_fields( + request_type=reaction.DeleteReactionRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -18766,21 +20411,21 @@ def test_create_reaction_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_reaction._get_unset_required_fields(jsonified_request) + ).delete_reaction._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_reaction._get_unset_required_fields(jsonified_request) + ).delete_reaction._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" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18789,7 +20434,7 @@ def test_create_reaction_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gc_reaction.Reaction() + return_value = None # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -18801,48 +20446,36 @@ def test_create_reaction_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = gc_reaction.Reaction.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_reaction(request) + response = client.delete_reaction(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_reaction_rest_unset_required_fields(): +def test_delete_reaction_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_reaction._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "reaction", - ) - ) - ) + unset_fields = transport.delete_reaction._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_reaction_rest_interceptors(null_interceptor): +def test_delete_reaction_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18855,15 +20488,10 @@ def test_create_reaction_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_create_reaction" - ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_create_reaction" + transports.ChatServiceRestInterceptor, "pre_delete_reaction" ) as pre: pre.assert_not_called() - post.assert_not_called() - pb_message = gc_reaction.CreateReactionRequest.pb( - gc_reaction.CreateReactionRequest() - ) + pb_message = reaction.DeleteReactionRequest.pb(reaction.DeleteReactionRequest()) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -18874,17 +20502,15 @@ def test_create_reaction_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gc_reaction.Reaction.to_json(gc_reaction.Reaction()) - request = gc_reaction.CreateReactionRequest() + request = reaction.DeleteReactionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gc_reaction.Reaction() - client.create_reaction( + client.delete_reaction( request, metadata=[ ("key", "val"), @@ -18893,11 +20519,10 @@ def test_create_reaction_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() -def test_create_reaction_rest_bad_request( - transport: str = "rest", request_type=gc_reaction.CreateReactionRequest +def test_delete_reaction_rest_bad_request( + transport: str = "rest", request_type=reaction.DeleteReactionRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -18905,7 +20530,7 @@ def test_create_reaction_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1/messages/sample2"} + request_init = {"name": "spaces/sample1/messages/sample2/reactions/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -18917,10 +20542,10 @@ def test_create_reaction_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.create_reaction(request) + client.delete_reaction(request) -def test_create_reaction_rest_flattened(): +def test_delete_reaction_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -18929,40 +20554,37 @@ def test_create_reaction_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_reaction.Reaction() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "spaces/sample1/messages/sample2"} + sample_request = {"name": "spaces/sample1/messages/sample2/reactions/sample3"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - reaction=gc_reaction.Reaction(name="name_value"), + name="name_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gc_reaction.Reaction.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.create_reaction(**mock_args) + client.delete_reaction(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=spaces/*/messages/*}/reactions" % client.transport._host, + "%s/v1/{name=spaces/*/messages/*/reactions/*}" % client.transport._host, args[1], ) -def test_create_reaction_rest_flattened_error(transport: str = "rest"): +def test_delete_reaction_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -18971,14 +20593,13 @@ def test_create_reaction_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_reaction( - gc_reaction.CreateReactionRequest(), - parent="parent_value", - reaction=gc_reaction.Reaction(name="name_value"), + client.delete_reaction( + reaction.DeleteReactionRequest(), + name="name_value", ) -def test_create_reaction_rest_error(): +def test_delete_reaction_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -18987,44 +20608,44 @@ def test_create_reaction_rest_error(): @pytest.mark.parametrize( "request_type", [ - reaction.ListReactionsRequest, + space_read_state.GetSpaceReadStateRequest, dict, ], ) -def test_list_reactions_rest(request_type): +def test_get_space_read_state_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1/messages/sample2"} + request_init = {"name": "users/sample1/spaces/sample2/spaceReadState"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = reaction.ListReactionsResponse( - next_page_token="next_page_token_value", + return_value = space_read_state.SpaceReadState( + name="name_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reaction.ListReactionsResponse.pb(return_value) + return_value = space_read_state.SpaceReadState.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.list_reactions(request) + response = client.get_space_read_state(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListReactionsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, space_read_state.SpaceReadState) + assert response.name == "name_value" -def test_list_reactions_rest_use_cached_wrapped_rpc(): +def test_get_space_read_state_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -19038,35 +20659,39 @@ def test_list_reactions_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_reactions in client._transport._wrapped_methods + assert ( + client._transport.get_space_read_state in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.list_reactions] = mock_rpc + client._transport._wrapped_methods[ + client._transport.get_space_read_state + ] = mock_rpc request = {} - client.list_reactions(request) + client.get_space_read_state(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_reactions(request) + client.get_space_read_state(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_list_reactions_rest_required_fields( - request_type=reaction.ListReactionsRequest, +def test_get_space_read_state_rest_required_fields( + request_type=space_read_state.GetSpaceReadStateRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -19077,29 +20702,21 @@ def test_list_reactions_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_reactions._get_unset_required_fields(jsonified_request) + ).get_space_read_state._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_reactions._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", - ) - ) + ).get_space_read_state._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" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19108,7 +20725,7 @@ def test_list_reactions_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reaction.ListReactionsResponse() + return_value = space_read_state.SpaceReadState() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -19129,39 +20746,30 @@ def test_list_reactions_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = reaction.ListReactionsResponse.pb(return_value) + return_value = space_read_state.SpaceReadState.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.list_reactions(request) + response = client.get_space_read_state(request) expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_list_reactions_rest_unset_required_fields(): - transport = transports.ChatServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.list_reactions._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_space_read_state_rest_unset_required_fields(): + transport = transports.ChatServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) + unset_fields = transport.get_space_read_state._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_reactions_rest_interceptors(null_interceptor): +def test_get_space_read_state_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -19174,13 +20782,15 @@ def test_list_reactions_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_list_reactions" + transports.ChatServiceRestInterceptor, "post_get_space_read_state" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_list_reactions" + transports.ChatServiceRestInterceptor, "pre_get_space_read_state" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = reaction.ListReactionsRequest.pb(reaction.ListReactionsRequest()) + pb_message = space_read_state.GetSpaceReadStateRequest.pb( + space_read_state.GetSpaceReadStateRequest() + ) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -19191,19 +20801,19 @@ def test_list_reactions_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = reaction.ListReactionsResponse.to_json( - reaction.ListReactionsResponse() + req.return_value._content = space_read_state.SpaceReadState.to_json( + space_read_state.SpaceReadState() ) - request = reaction.ListReactionsRequest() + request = space_read_state.GetSpaceReadStateRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reaction.ListReactionsResponse() + post.return_value = space_read_state.SpaceReadState() - client.list_reactions( + client.get_space_read_state( request, metadata=[ ("key", "val"), @@ -19215,8 +20825,8 @@ def test_list_reactions_rest_interceptors(null_interceptor): post.assert_called_once() -def test_list_reactions_rest_bad_request( - transport: str = "rest", request_type=reaction.ListReactionsRequest +def test_get_space_read_state_rest_bad_request( + transport: str = "rest", request_type=space_read_state.GetSpaceReadStateRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19224,7 +20834,7 @@ def test_list_reactions_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"parent": "spaces/sample1/messages/sample2"} + request_init = {"name": "users/sample1/spaces/sample2/spaceReadState"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -19236,10 +20846,10 @@ def test_list_reactions_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.list_reactions(request) + client.get_space_read_state(request) -def test_list_reactions_rest_flattened(): +def test_get_space_read_state_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -19248,14 +20858,14 @@ def test_list_reactions_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = reaction.ListReactionsResponse() + return_value = space_read_state.SpaceReadState() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "spaces/sample1/messages/sample2"} + sample_request = {"name": "users/sample1/spaces/sample2/spaceReadState"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) @@ -19263,24 +20873,24 @@ def test_list_reactions_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reaction.ListReactionsResponse.pb(return_value) + return_value = space_read_state.SpaceReadState.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.list_reactions(**mock_args) + client.get_space_read_state(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=spaces/*/messages/*}/reactions" % client.transport._host, + "%s/v1/{name=users/*/spaces/*/spaceReadState}" % client.transport._host, args[1], ) -def test_list_reactions_rest_flattened_error(transport: str = "rest"): +def test_get_space_read_state_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -19289,109 +20899,134 @@ def test_list_reactions_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_reactions( - reaction.ListReactionsRequest(), - parent="parent_value", + client.get_space_read_state( + space_read_state.GetSpaceReadStateRequest(), + name="name_value", ) -def test_list_reactions_rest_pager(transport: str = "rest"): +def test_get_space_read_state_rest_error(): client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - reaction.ListReactionsResponse( - reactions=[ - reaction.Reaction(), - reaction.Reaction(), - reaction.Reaction(), - ], - next_page_token="abc", - ), - reaction.ListReactionsResponse( - reactions=[], - next_page_token="def", - ), - reaction.ListReactionsResponse( - reactions=[ - reaction.Reaction(), - ], - next_page_token="ghi", - ), - reaction.ListReactionsResponse( - reactions=[ - reaction.Reaction(), - reaction.Reaction(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple(reaction.ListReactionsResponse.to_json(x) for x in response) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - - sample_request = {"parent": "spaces/sample1/messages/sample2"} - - pager = client.list_reactions(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, reaction.Reaction) for i in results) - - pages = list(client.list_reactions(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - @pytest.mark.parametrize( "request_type", [ - reaction.DeleteReactionRequest, + gc_space_read_state.UpdateSpaceReadStateRequest, dict, ], ) -def test_delete_reaction_rest(request_type): +def test_update_space_read_state_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/messages/sample2/reactions/sample3"} + request_init = { + "space_read_state": {"name": "users/sample1/spaces/sample2/spaceReadState"} + } + request_init["space_read_state"] = { + "name": "users/sample1/spaces/sample2/spaceReadState", + "last_read_time": {"seconds": 751, "nanos": 543}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = gc_space_read_state.UpdateSpaceReadStateRequest.meta.fields[ + "space_read_state" + ] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["space_read_state"].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["space_read_state"][field])): + del request_init["space_read_state"][field][i][subfield] + else: + del request_init["space_read_state"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = gc_space_read_state.SpaceReadState( + name="name_value", + ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + # Convert return value to protobuf type + return_value = gc_space_read_state.SpaceReadState.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_reaction(request) + response = client.update_space_read_state(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, gc_space_read_state.SpaceReadState) + assert response.name == "name_value" -def test_delete_reaction_rest_use_cached_wrapped_rpc(): +def test_update_space_read_state_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -19405,35 +21040,39 @@ def test_delete_reaction_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_reaction in client._transport._wrapped_methods + assert ( + client._transport.update_space_read_state + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[client._transport.delete_reaction] = mock_rpc + client._transport._wrapped_methods[ + client._transport.update_space_read_state + ] = mock_rpc request = {} - client.delete_reaction(request) + client.update_space_read_state(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_reaction(request) + client.update_space_read_state(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_reaction_rest_required_fields( - request_type=reaction.DeleteReactionRequest, +def test_update_space_read_state_rest_required_fields( + request_type=gc_space_read_state.UpdateSpaceReadStateRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -19444,21 +21083,19 @@ def test_delete_reaction_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_reaction._get_unset_required_fields(jsonified_request) + ).update_space_read_state._get_unset_required_fields(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_reaction._get_unset_required_fields(jsonified_request) + ).update_space_read_state._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) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19467,7 +21104,7 @@ def test_delete_reaction_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = gc_space_read_state.SpaceReadState() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -19479,36 +21116,48 @@ def test_delete_reaction_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "patch", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = gc_space_read_state.SpaceReadState.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.delete_reaction(request) + response = client.update_space_read_state(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_reaction_rest_unset_required_fields(): +def test_update_space_read_state_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_reaction._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.update_space_read_state._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "spaceReadState", + "updateMask", + ) + ) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_reaction_rest_interceptors(null_interceptor): +def test_update_space_read_state_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -19521,10 +21170,15 @@ def test_delete_reaction_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_delete_reaction" + transports.ChatServiceRestInterceptor, "post_update_space_read_state" + ) as post, mock.patch.object( + transports.ChatServiceRestInterceptor, "pre_update_space_read_state" ) as pre: pre.assert_not_called() - pb_message = reaction.DeleteReactionRequest.pb(reaction.DeleteReactionRequest()) + post.assert_not_called() + pb_message = gc_space_read_state.UpdateSpaceReadStateRequest.pb( + gc_space_read_state.UpdateSpaceReadStateRequest() + ) transcode.return_value = { "method": "post", "uri": "my_uri", @@ -19535,15 +21189,19 @@ def test_delete_reaction_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() + req.return_value._content = gc_space_read_state.SpaceReadState.to_json( + gc_space_read_state.SpaceReadState() + ) - request = reaction.DeleteReactionRequest() + request = gc_space_read_state.UpdateSpaceReadStateRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = gc_space_read_state.SpaceReadState() - client.delete_reaction( + client.update_space_read_state( request, metadata=[ ("key", "val"), @@ -19552,10 +21210,12 @@ def test_delete_reaction_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() -def test_delete_reaction_rest_bad_request( - transport: str = "rest", request_type=reaction.DeleteReactionRequest +def test_update_space_read_state_rest_bad_request( + transport: str = "rest", + request_type=gc_space_read_state.UpdateSpaceReadStateRequest, ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19563,7 +21223,9 @@ def test_delete_reaction_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "spaces/sample1/messages/sample2/reactions/sample3"} + request_init = { + "space_read_state": {"name": "users/sample1/spaces/sample2/spaceReadState"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -19575,10 +21237,10 @@ def test_delete_reaction_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.delete_reaction(request) + client.update_space_read_state(request) -def test_delete_reaction_rest_flattened(): +def test_update_space_read_state_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -19587,37 +21249,43 @@ def test_delete_reaction_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = gc_space_read_state.SpaceReadState() # get arguments that satisfy an http rule for this method - sample_request = {"name": "spaces/sample1/messages/sample2/reactions/sample3"} + sample_request = { + "space_read_state": {"name": "users/sample1/spaces/sample2/spaceReadState"} + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + space_read_state=gc_space_read_state.SpaceReadState(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + # Convert return value to protobuf type + return_value = gc_space_read_state.SpaceReadState.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.delete_reaction(**mock_args) + client.update_space_read_state(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=spaces/*/messages/*/reactions/*}" % client.transport._host, + "%s/v1/{space_read_state.name=users/*/spaces/*/spaceReadState}" + % client.transport._host, args[1], ) -def test_delete_reaction_rest_flattened_error(transport: str = "rest"): +def test_update_space_read_state_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -19626,13 +21294,14 @@ def test_delete_reaction_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_reaction( - reaction.DeleteReactionRequest(), - name="name_value", + client.update_space_read_state( + gc_space_read_state.UpdateSpaceReadStateRequest(), + space_read_state=gc_space_read_state.SpaceReadState(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_reaction_rest_error(): +def test_update_space_read_state_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -19641,24 +21310,26 @@ def test_delete_reaction_rest_error(): @pytest.mark.parametrize( "request_type", [ - space_read_state.GetSpaceReadStateRequest, + thread_read_state.GetThreadReadStateRequest, dict, ], ) -def test_get_space_read_state_rest(request_type): +def test_get_thread_read_state_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "users/sample1/spaces/sample2/spaceReadState"} + request_init = { + "name": "users/sample1/spaces/sample2/threads/sample3/threadReadState" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = space_read_state.SpaceReadState( + return_value = thread_read_state.ThreadReadState( name="name_value", ) @@ -19666,19 +21337,19 @@ def test_get_space_read_state_rest(request_type): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = space_read_state.SpaceReadState.pb(return_value) + return_value = thread_read_state.ThreadReadState.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_space_read_state(request) + response = client.get_thread_read_state(request) # Establish that the response is the type that we expect. - assert isinstance(response, space_read_state.SpaceReadState) + assert isinstance(response, thread_read_state.ThreadReadState) assert response.name == "name_value" -def test_get_space_read_state_rest_use_cached_wrapped_rpc(): +def test_get_thread_read_state_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -19693,7 +21364,8 @@ def test_get_space_read_state_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_space_read_state in client._transport._wrapped_methods + client._transport.get_thread_read_state + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -19702,24 +21374,24 @@ def test_get_space_read_state_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_space_read_state + client._transport.get_thread_read_state ] = mock_rpc request = {} - client.get_space_read_state(request) + client.get_thread_read_state(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_space_read_state(request) + client.get_thread_read_state(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_get_space_read_state_rest_required_fields( - request_type=space_read_state.GetSpaceReadStateRequest, +def test_get_thread_read_state_rest_required_fields( + request_type=thread_read_state.GetThreadReadStateRequest, ): transport_class = transports.ChatServiceRestTransport @@ -19735,7 +21407,7 @@ def test_get_space_read_state_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_space_read_state._get_unset_required_fields(jsonified_request) + ).get_thread_read_state._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -19744,7 +21416,7 @@ def test_get_space_read_state_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_space_read_state._get_unset_required_fields(jsonified_request) + ).get_thread_read_state._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -19758,7 +21430,7 @@ def test_get_space_read_state_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = space_read_state.SpaceReadState() + return_value = thread_read_state.ThreadReadState() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -19779,30 +21451,30 @@ def test_get_space_read_state_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = space_read_state.SpaceReadState.pb(return_value) + return_value = thread_read_state.ThreadReadState.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_space_read_state(request) + response = client.get_thread_read_state(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_space_read_state_rest_unset_required_fields(): +def test_get_thread_read_state_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_space_read_state._get_unset_required_fields({}) + unset_fields = transport.get_thread_read_state._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_space_read_state_rest_interceptors(null_interceptor): +def test_get_thread_read_state_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -19815,14 +21487,14 @@ def test_get_space_read_state_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_get_space_read_state" + transports.ChatServiceRestInterceptor, "post_get_thread_read_state" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_get_space_read_state" + transports.ChatServiceRestInterceptor, "pre_get_thread_read_state" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = space_read_state.GetSpaceReadStateRequest.pb( - space_read_state.GetSpaceReadStateRequest() + pb_message = thread_read_state.GetThreadReadStateRequest.pb( + thread_read_state.GetThreadReadStateRequest() ) transcode.return_value = { "method": "post", @@ -19834,19 +21506,19 @@ def test_get_space_read_state_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = space_read_state.SpaceReadState.to_json( - space_read_state.SpaceReadState() + req.return_value._content = thread_read_state.ThreadReadState.to_json( + thread_read_state.ThreadReadState() ) - request = space_read_state.GetSpaceReadStateRequest() + request = thread_read_state.GetThreadReadStateRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = space_read_state.SpaceReadState() + post.return_value = thread_read_state.ThreadReadState() - client.get_space_read_state( + client.get_thread_read_state( request, metadata=[ ("key", "val"), @@ -19858,8 +21530,8 @@ def test_get_space_read_state_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_space_read_state_rest_bad_request( - transport: str = "rest", request_type=space_read_state.GetSpaceReadStateRequest +def test_get_thread_read_state_rest_bad_request( + transport: str = "rest", request_type=thread_read_state.GetThreadReadStateRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -19867,7 +21539,9 @@ def test_get_space_read_state_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "users/sample1/spaces/sample2/spaceReadState"} + request_init = { + "name": "users/sample1/spaces/sample2/threads/sample3/threadReadState" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -19879,10 +21553,10 @@ def test_get_space_read_state_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_space_read_state(request) + client.get_thread_read_state(request) -def test_get_space_read_state_rest_flattened(): +def test_get_thread_read_state_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -19891,10 +21565,12 @@ def test_get_space_read_state_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = space_read_state.SpaceReadState() + return_value = thread_read_state.ThreadReadState() # get arguments that satisfy an http rule for this method - sample_request = {"name": "users/sample1/spaces/sample2/spaceReadState"} + sample_request = { + "name": "users/sample1/spaces/sample2/threads/sample3/threadReadState" + } # get truthy value for each flattened field mock_args = dict( @@ -19906,24 +21582,25 @@ def test_get_space_read_state_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = space_read_state.SpaceReadState.pb(return_value) + return_value = thread_read_state.ThreadReadState.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_space_read_state(**mock_args) + client.get_thread_read_state(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=users/*/spaces/*/spaceReadState}" % client.transport._host, + "%s/v1/{name=users/*/spaces/*/threads/*/threadReadState}" + % client.transport._host, args[1], ) -def test_get_space_read_state_rest_flattened_error(transport: str = "rest"): +def test_get_thread_read_state_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -19932,13 +21609,13 @@ def test_get_space_read_state_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_space_read_state( - space_read_state.GetSpaceReadStateRequest(), + client.get_thread_read_state( + thread_read_state.GetThreadReadStateRequest(), name="name_value", ) -def test_get_space_read_state_rest_error(): +def test_get_thread_read_state_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -19947,119 +21624,46 @@ def test_get_space_read_state_rest_error(): @pytest.mark.parametrize( "request_type", [ - gc_space_read_state.UpdateSpaceReadStateRequest, + space_event.GetSpaceEventRequest, dict, ], ) -def test_update_space_read_state_rest(request_type): +def test_get_space_event_rest(request_type): client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # send a request that will satisfy transcoding - request_init = { - "space_read_state": {"name": "users/sample1/spaces/sample2/spaceReadState"} - } - request_init["space_read_state"] = { - "name": "users/sample1/spaces/sample2/spaceReadState", - "last_read_time": {"seconds": 751, "nanos": 543}, - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = gc_space_read_state.UpdateSpaceReadStateRequest.meta.fields[ - "space_read_state" - ] - - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] - - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") - - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields - - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] - - subfields_not_in_runtime = [] - - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["space_read_state"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value - - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) - - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["space_read_state"][field])): - del request_init["space_read_state"][field][i][subfield] - else: - del request_init["space_read_state"][field][subfield] + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "spaces/sample1/spaceEvents/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_space_read_state.SpaceReadState( + return_value = space_event.SpaceEvent( name="name_value", + event_type="event_type_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_space_read_state.SpaceReadState.pb(return_value) + return_value = space_event.SpaceEvent.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_space_read_state(request) + response = client.get_space_event(request) # Establish that the response is the type that we expect. - assert isinstance(response, gc_space_read_state.SpaceReadState) + assert isinstance(response, space_event.SpaceEvent) assert response.name == "name_value" + assert response.event_type == "event_type_value" -def test_update_space_read_state_rest_use_cached_wrapped_rpc(): +def test_get_space_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -20073,39 +21677,35 @@ def test_update_space_read_state_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_space_read_state - in client._transport._wrapped_methods - ) + assert client._transport.get_space_event in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[ - client._transport.update_space_read_state - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_space_event] = mock_rpc request = {} - client.update_space_read_state(request) + client.get_space_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_space_read_state(request) + client.get_space_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_space_read_state_rest_required_fields( - request_type=gc_space_read_state.UpdateSpaceReadStateRequest, +def test_get_space_event_rest_required_fields( + request_type=space_event.GetSpaceEventRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -20116,19 +21716,21 @@ def test_update_space_read_state_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_space_read_state._get_unset_required_fields(jsonified_request) + ).get_space_event._get_unset_required_fields(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() - ).update_space_read_state._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",)) + ).get_space_event._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" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20137,7 +21739,7 @@ def test_update_space_read_state_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gc_space_read_state.SpaceReadState() + return_value = space_event.SpaceEvent() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -20149,48 +21751,39 @@ def test_update_space_read_state_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_space_read_state.SpaceReadState.pb(return_value) + return_value = space_event.SpaceEvent.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_space_read_state(request) + response = client.get_space_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_space_read_state_rest_unset_required_fields(): +def test_get_space_event_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_space_read_state._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "spaceReadState", - "updateMask", - ) - ) - ) + unset_fields = transport.get_space_event._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_space_read_state_rest_interceptors(null_interceptor): +def test_get_space_event_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -20203,14 +21796,14 @@ def test_update_space_read_state_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_update_space_read_state" + transports.ChatServiceRestInterceptor, "post_get_space_event" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_update_space_read_state" + transports.ChatServiceRestInterceptor, "pre_get_space_event" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = gc_space_read_state.UpdateSpaceReadStateRequest.pb( - gc_space_read_state.UpdateSpaceReadStateRequest() + pb_message = space_event.GetSpaceEventRequest.pb( + space_event.GetSpaceEventRequest() ) transcode.return_value = { "method": "post", @@ -20222,19 +21815,19 @@ def test_update_space_read_state_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gc_space_read_state.SpaceReadState.to_json( - gc_space_read_state.SpaceReadState() + req.return_value._content = space_event.SpaceEvent.to_json( + space_event.SpaceEvent() ) - request = gc_space_read_state.UpdateSpaceReadStateRequest() + request = space_event.GetSpaceEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gc_space_read_state.SpaceReadState() + post.return_value = space_event.SpaceEvent() - client.update_space_read_state( + client.get_space_event( request, metadata=[ ("key", "val"), @@ -20246,9 +21839,8 @@ def test_update_space_read_state_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_space_read_state_rest_bad_request( - transport: str = "rest", - request_type=gc_space_read_state.UpdateSpaceReadStateRequest, +def test_get_space_event_rest_bad_request( + transport: str = "rest", request_type=space_event.GetSpaceEventRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20256,9 +21848,7 @@ def test_update_space_read_state_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = { - "space_read_state": {"name": "users/sample1/spaces/sample2/spaceReadState"} - } + request_init = {"name": "spaces/sample1/spaceEvents/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -20270,10 +21860,10 @@ def test_update_space_read_state_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.update_space_read_state(request) + client.get_space_event(request) -def test_update_space_read_state_rest_flattened(): +def test_get_space_event_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -20282,17 +21872,14 @@ def test_update_space_read_state_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = gc_space_read_state.SpaceReadState() + return_value = space_event.SpaceEvent() # get arguments that satisfy an http rule for this method - sample_request = { - "space_read_state": {"name": "users/sample1/spaces/sample2/spaceReadState"} - } + sample_request = {"name": "spaces/sample1/spaceEvents/sample2"} # get truthy value for each flattened field mock_args = dict( - space_read_state=gc_space_read_state.SpaceReadState(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) @@ -20300,25 +21887,23 @@ def test_update_space_read_state_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gc_space_read_state.SpaceReadState.pb(return_value) + return_value = space_event.SpaceEvent.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.update_space_read_state(**mock_args) + client.get_space_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{space_read_state.name=users/*/spaces/*/spaceReadState}" - % client.transport._host, - args[1], + "%s/v1/{name=spaces/*/spaceEvents/*}" % client.transport._host, args[1] ) -def test_update_space_read_state_rest_flattened_error(transport: str = "rest"): +def test_get_space_event_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -20327,14 +21912,13 @@ def test_update_space_read_state_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_space_read_state( - gc_space_read_state.UpdateSpaceReadStateRequest(), - space_read_state=gc_space_read_state.SpaceReadState(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_space_event( + space_event.GetSpaceEventRequest(), + name="name_value", ) -def test_update_space_read_state_rest_error(): +def test_get_space_event_rest_error(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -20343,46 +21927,44 @@ def test_update_space_read_state_rest_error(): @pytest.mark.parametrize( "request_type", [ - thread_read_state.GetThreadReadStateRequest, + space_event.ListSpaceEventsRequest, dict, ], ) -def test_get_thread_read_state_rest(request_type): +def test_list_space_events_rest(request_type): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = { - "name": "users/sample1/spaces/sample2/threads/sample3/threadReadState" - } + request_init = {"parent": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = thread_read_state.ThreadReadState( - name="name_value", + return_value = space_event.ListSpaceEventsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = thread_read_state.ThreadReadState.pb(return_value) + return_value = space_event.ListSpaceEventsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_thread_read_state(request) + response = client.list_space_events(request) # Establish that the response is the type that we expect. - assert isinstance(response, thread_read_state.ThreadReadState) - assert response.name == "name_value" + assert isinstance(response, pagers.ListSpaceEventsPager) + assert response.next_page_token == "next_page_token_value" -def test_get_thread_read_state_rest_use_cached_wrapped_rpc(): +def test_list_space_events_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -20396,10 +21978,7 @@ def test_get_thread_read_state_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_thread_read_state - in client._transport._wrapped_methods - ) + assert client._transport.list_space_events in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -20407,29 +21986,30 @@ def test_get_thread_read_state_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_thread_read_state + client._transport.list_space_events ] = mock_rpc request = {} - client.get_thread_read_state(request) + client.list_space_events(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_thread_read_state(request) + client.list_space_events(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_get_thread_read_state_rest_required_fields( - request_type=thread_read_state.GetThreadReadStateRequest, +def test_list_space_events_rest_required_fields( + request_type=space_event.ListSpaceEventsRequest, ): transport_class = transports.ChatServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" + request_init["filter"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -20437,24 +22017,38 @@ def test_get_thread_read_state_rest_required_fields( ) # verify fields with default values are dropped + assert "filter" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_thread_read_state._get_unset_required_fields(jsonified_request) + ).list_space_events._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "filter" in jsonified_request + assert jsonified_request["filter"] == request_init["filter"] - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" + jsonified_request["filter"] = "filter_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_thread_read_state._get_unset_required_fields(jsonified_request) + ).list_space_events._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) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "filter" in jsonified_request + assert jsonified_request["filter"] == "filter_value" client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20463,7 +22057,7 @@ def test_get_thread_read_state_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = thread_read_state.ThreadReadState() + return_value = space_event.ListSpaceEventsResponse() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -20484,30 +22078,50 @@ def test_get_thread_read_state_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = thread_read_state.ThreadReadState.pb(return_value) + return_value = space_event.ListSpaceEventsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_thread_read_state(request) + response = client.list_space_events(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "filter", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_thread_read_state_rest_unset_required_fields(): +def test_list_space_events_rest_unset_required_fields(): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_thread_read_state._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.list_space_events._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set( + ( + "parent", + "filter", + ) + ) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_thread_read_state_rest_interceptors(null_interceptor): +def test_list_space_events_rest_interceptors(null_interceptor): transport = transports.ChatServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -20520,14 +22134,14 @@ def test_get_thread_read_state_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ChatServiceRestInterceptor, "post_get_thread_read_state" + transports.ChatServiceRestInterceptor, "post_list_space_events" ) as post, mock.patch.object( - transports.ChatServiceRestInterceptor, "pre_get_thread_read_state" + transports.ChatServiceRestInterceptor, "pre_list_space_events" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = thread_read_state.GetThreadReadStateRequest.pb( - thread_read_state.GetThreadReadStateRequest() + pb_message = space_event.ListSpaceEventsRequest.pb( + space_event.ListSpaceEventsRequest() ) transcode.return_value = { "method": "post", @@ -20539,19 +22153,19 @@ def test_get_thread_read_state_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = thread_read_state.ThreadReadState.to_json( - thread_read_state.ThreadReadState() + req.return_value._content = space_event.ListSpaceEventsResponse.to_json( + space_event.ListSpaceEventsResponse() ) - request = thread_read_state.GetThreadReadStateRequest() + request = space_event.ListSpaceEventsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = thread_read_state.ThreadReadState() + post.return_value = space_event.ListSpaceEventsResponse() - client.get_thread_read_state( + client.list_space_events( request, metadata=[ ("key", "val"), @@ -20563,8 +22177,8 @@ def test_get_thread_read_state_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_thread_read_state_rest_bad_request( - transport: str = "rest", request_type=thread_read_state.GetThreadReadStateRequest +def test_list_space_events_rest_bad_request( + transport: str = "rest", request_type=space_event.ListSpaceEventsRequest ): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -20572,9 +22186,7 @@ def test_get_thread_read_state_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = { - "name": "users/sample1/spaces/sample2/threads/sample3/threadReadState" - } + request_init = {"parent": "spaces/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -20586,10 +22198,10 @@ def test_get_thread_read_state_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_thread_read_state(request) + client.list_space_events(request) -def test_get_thread_read_state_rest_flattened(): +def test_list_space_events_rest_flattened(): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -20598,16 +22210,15 @@ def test_get_thread_read_state_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = thread_read_state.ThreadReadState() + return_value = space_event.ListSpaceEventsResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "users/sample1/spaces/sample2/threads/sample3/threadReadState" - } + sample_request = {"parent": "spaces/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + filter="filter_value", ) mock_args.update(sample_request) @@ -20615,25 +22226,23 @@ def test_get_thread_read_state_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = thread_read_state.ThreadReadState.pb(return_value) + return_value = space_event.ListSpaceEventsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_thread_read_state(**mock_args) + client.list_space_events(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=users/*/spaces/*/threads/*/threadReadState}" - % client.transport._host, - args[1], + "%s/v1/{parent=spaces/*}/spaceEvents" % client.transport._host, args[1] ) -def test_get_thread_read_state_rest_flattened_error(transport: str = "rest"): +def test_list_space_events_rest_flattened_error(transport: str = "rest"): client = ChatServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -20642,17 +22251,75 @@ def test_get_thread_read_state_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_thread_read_state( - thread_read_state.GetThreadReadStateRequest(), - name="name_value", + client.list_space_events( + space_event.ListSpaceEventsRequest(), + parent="parent_value", + filter="filter_value", ) -def test_get_thread_read_state_rest_error(): +def test_list_space_events_rest_pager(transport: str = "rest"): client = ChatServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + next_page_token="abc", + ), + space_event.ListSpaceEventsResponse( + space_events=[], + next_page_token="def", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + ], + next_page_token="ghi", + ), + space_event.ListSpaceEventsResponse( + space_events=[ + space_event.SpaceEvent(), + space_event.SpaceEvent(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + space_event.ListSpaceEventsResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "spaces/sample1"} + + pager = client.list_space_events(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, space_event.SpaceEvent) for i in results) + + pages = list(client.list_space_events(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + def test_credentials_transport_error(): # It is an error to provide credentials and a transport instance. @@ -20819,6 +22486,8 @@ def test_chat_service_base_transport(): "get_space_read_state", "update_space_read_state", "get_thread_read_state", + "get_space_event", + "list_space_events", ) for method in methods: with pytest.raises(NotImplementedError): @@ -21242,6 +22911,12 @@ def test_chat_service_client_transport_session_collision(transport_name): session1 = client1.transport.get_thread_read_state._session session2 = client2.transport.get_thread_read_state._session assert session1 != session2 + session1 = client1.transport.get_space_event._session + session2 = client2.transport.get_space_event._session + assert session1 != session2 + session1 = client1.transport.list_space_events._session + session2 = client2.transport.list_space_events._session + assert session1 != session2 def test_chat_service_grpc_transport_channel(): @@ -21508,9 +23183,32 @@ def test_parse_space_path(): assert expected == actual +def test_space_event_path(): + space = "oyster" + space_event = "nudibranch" + expected = "spaces/{space}/spaceEvents/{space_event}".format( + space=space, + space_event=space_event, + ) + actual = ChatServiceClient.space_event_path(space, space_event) + assert expected == actual + + +def test_parse_space_event_path(): + expected = { + "space": "cuttlefish", + "space_event": "mussel", + } + path = ChatServiceClient.space_event_path(**expected) + + # Check that the path construction is reversible. + actual = ChatServiceClient.parse_space_event_path(path) + assert expected == actual + + def test_space_read_state_path(): - user = "oyster" - space = "nudibranch" + user = "winkle" + space = "nautilus" expected = "users/{user}/spaces/{space}/spaceReadState".format( user=user, space=space, @@ -21521,8 +23219,8 @@ def test_space_read_state_path(): def test_parse_space_read_state_path(): expected = { - "user": "cuttlefish", - "space": "mussel", + "user": "scallop", + "space": "abalone", } path = ChatServiceClient.space_read_state_path(**expected) @@ -21532,8 +23230,8 @@ def test_parse_space_read_state_path(): def test_thread_path(): - space = "winkle" - thread = "nautilus" + space = "squid" + thread = "clam" expected = "spaces/{space}/threads/{thread}".format( space=space, thread=thread, @@ -21544,8 +23242,8 @@ def test_thread_path(): def test_parse_thread_path(): expected = { - "space": "scallop", - "thread": "abalone", + "space": "whelk", + "thread": "octopus", } path = ChatServiceClient.thread_path(**expected) @@ -21555,9 +23253,9 @@ def test_parse_thread_path(): def test_thread_read_state_path(): - user = "squid" - space = "clam" - thread = "whelk" + user = "oyster" + space = "nudibranch" + thread = "cuttlefish" expected = "users/{user}/spaces/{space}/threads/{thread}/threadReadState".format( user=user, space=space, @@ -21569,9 +23267,9 @@ def test_thread_read_state_path(): def test_parse_thread_read_state_path(): expected = { - "user": "octopus", - "space": "oyster", - "thread": "nudibranch", + "user": "mussel", + "space": "winkle", + "thread": "nautilus", } path = ChatServiceClient.thread_read_state_path(**expected) @@ -21581,7 +23279,7 @@ def test_parse_thread_read_state_path(): def test_common_billing_account_path(): - billing_account = "cuttlefish" + billing_account = "scallop" expected = "billingAccounts/{billing_account}".format( billing_account=billing_account, ) @@ -21591,7 +23289,7 @@ def test_common_billing_account_path(): def test_parse_common_billing_account_path(): expected = { - "billing_account": "mussel", + "billing_account": "abalone", } path = ChatServiceClient.common_billing_account_path(**expected) @@ -21601,7 +23299,7 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): - folder = "winkle" + folder = "squid" expected = "folders/{folder}".format( folder=folder, ) @@ -21611,7 +23309,7 @@ def test_common_folder_path(): def test_parse_common_folder_path(): expected = { - "folder": "nautilus", + "folder": "clam", } path = ChatServiceClient.common_folder_path(**expected) @@ -21621,7 +23319,7 @@ def test_parse_common_folder_path(): def test_common_organization_path(): - organization = "scallop" + organization = "whelk" expected = "organizations/{organization}".format( organization=organization, ) @@ -21631,7 +23329,7 @@ def test_common_organization_path(): def test_parse_common_organization_path(): expected = { - "organization": "abalone", + "organization": "octopus", } path = ChatServiceClient.common_organization_path(**expected) @@ -21641,7 +23339,7 @@ def test_parse_common_organization_path(): def test_common_project_path(): - project = "squid" + project = "oyster" expected = "projects/{project}".format( project=project, ) @@ -21651,7 +23349,7 @@ def test_common_project_path(): def test_parse_common_project_path(): expected = { - "project": "clam", + "project": "nudibranch", } path = ChatServiceClient.common_project_path(**expected) @@ -21661,8 +23359,8 @@ def test_parse_common_project_path(): def test_common_location_path(): - project = "whelk" - location = "octopus" + project = "cuttlefish" + location = "mussel" expected = "projects/{project}/locations/{location}".format( project=project, location=location, @@ -21673,8 +23371,8 @@ def test_common_location_path(): def test_parse_common_location_path(): expected = { - "project": "oyster", - "location": "nudibranch", + "project": "winkle", + "location": "nautilus", } path = ChatServiceClient.common_location_path(**expected)