diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/__init__.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/__init__.py index b8805535d25b..721591d7f3cb 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/__init__.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/__init__.py @@ -19,7 +19,7 @@ from .services.recommender import RecommenderAsyncClient, RecommenderClient -from .types.insight import Insight, InsightStateInfo +from .types.insight import Insight, InsightStateInfo, InsightType from .types.insight_type_config import InsightTypeConfig, InsightTypeGenerationConfig from .types.recommendation import ( CostProjection, @@ -29,6 +29,7 @@ Recommendation, RecommendationContent, RecommendationStateInfo, + RecommenderType, SecurityProjection, SustainabilityProjection, ValueMatcher, @@ -41,8 +42,12 @@ GetRecommenderConfigRequest, ListInsightsRequest, ListInsightsResponse, + ListInsightTypesRequest, + ListInsightTypesResponse, ListRecommendationsRequest, ListRecommendationsResponse, + ListRecommendersRequest, + ListRecommendersResponse, MarkInsightAcceptedRequest, MarkRecommendationClaimedRequest, MarkRecommendationFailedRequest, @@ -61,12 +66,17 @@ "Impact", "Insight", "InsightStateInfo", + "InsightType", "InsightTypeConfig", "InsightTypeGenerationConfig", + "ListInsightTypesRequest", + "ListInsightTypesResponse", "ListInsightsRequest", "ListInsightsResponse", "ListRecommendationsRequest", "ListRecommendationsResponse", + "ListRecommendersRequest", + "ListRecommendersResponse", "MarkInsightAcceptedRequest", "MarkRecommendationClaimedRequest", "MarkRecommendationFailedRequest", @@ -79,6 +89,7 @@ "RecommenderClient", "RecommenderConfig", "RecommenderGenerationConfig", + "RecommenderType", "SecurityProjection", "SustainabilityProjection", "UpdateInsightTypeConfigRequest", diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/gapic_metadata.json b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/gapic_metadata.json index 667c3e4766f4..7cf1ed9c25b6 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/gapic_metadata.json +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/gapic_metadata.json @@ -30,6 +30,11 @@ "get_recommender_config" ] }, + "ListInsightTypes": { + "methods": [ + "list_insight_types" + ] + }, "ListInsights": { "methods": [ "list_insights" @@ -40,6 +45,11 @@ "list_recommendations" ] }, + "ListRecommenders": { + "methods": [ + "list_recommenders" + ] + }, "MarkInsightAccepted": { "methods": [ "mark_insight_accepted" @@ -95,6 +105,11 @@ "get_recommender_config" ] }, + "ListInsightTypes": { + "methods": [ + "list_insight_types" + ] + }, "ListInsights": { "methods": [ "list_insights" @@ -105,6 +120,11 @@ "list_recommendations" ] }, + "ListRecommenders": { + "methods": [ + "list_recommenders" + ] + }, "MarkInsightAccepted": { "methods": [ "mark_insight_accepted" @@ -160,6 +180,11 @@ "get_recommender_config" ] }, + "ListInsightTypes": { + "methods": [ + "list_insight_types" + ] + }, "ListInsights": { "methods": [ "list_insights" @@ -170,6 +195,11 @@ "list_recommendations" ] }, + "ListRecommenders": { + "methods": [ + "list_recommenders" + ] + }, "MarkInsightAccepted": { "methods": [ "mark_insight_accepted" diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/async_client.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/async_client.py index 802649c350bd..5d86a7265acc 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/async_client.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/async_client.py @@ -442,7 +442,7 @@ async def sample_get_insight(): google.cloud.recommender_v1beta1.types.Insight: An insight along with the information used to derive the insight. The insight - may have associated recomendations as + may have associated recommendations as well. """ @@ -579,7 +579,7 @@ async def sample_mark_insight_accepted(): google.cloud.recommender_v1beta1.types.Insight: An insight along with the information used to derive the insight. The insight - may have associated recomendations as + may have associated recommendations as well. """ @@ -1769,6 +1769,180 @@ async def sample_update_insight_type_config(): # Done; return the response. return response + async def list_recommenders( + self, + request: Optional[ + Union[recommender_service.ListRecommendersRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListRecommendersAsyncPager: + r"""Lists all available Recommenders. + No IAM permissions are required. + + .. 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.cloud import recommender_v1beta1 + + async def sample_list_recommenders(): + # Create a client + client = recommender_v1beta1.RecommenderAsyncClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListRecommendersRequest( + ) + + # Make the request + page_result = client.list_recommenders(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.recommender_v1beta1.types.ListRecommendersRequest, dict]]): + The request object. Request for the ``ListRecommender`` method. + 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.cloud.recommender_v1beta1.services.recommender.pagers.ListRecommendersAsyncPager: + Response for the ListRecommender method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + request = recommender_service.ListRecommendersRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.list_recommenders, + default_timeout=None, + client_info=DEFAULT_CLIENT_INFO, + ) + + # 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.ListRecommendersAsyncPager( + method=rpc, + request=request, + response=response, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_insight_types( + self, + request: Optional[ + Union[recommender_service.ListInsightTypesRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListInsightTypesAsyncPager: + r"""Lists available InsightTypes. + No IAM permissions are required. + + .. 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.cloud import recommender_v1beta1 + + async def sample_list_insight_types(): + # Create a client + client = recommender_v1beta1.RecommenderAsyncClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListInsightTypesRequest( + ) + + # Make the request + page_result = client.list_insight_types(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.recommender_v1beta1.types.ListInsightTypesRequest, dict]]): + The request object. Request for the ``ListInsightTypes`` method. + 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.cloud.recommender_v1beta1.services.recommender.pagers.ListInsightTypesAsyncPager: + Response for the ListInsightTypes method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + request = recommender_service.ListInsightTypesRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.list_insight_types, + default_timeout=None, + client_info=DEFAULT_CLIENT_INFO, + ) + + # 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.ListInsightTypesAsyncPager( + method=rpc, + request=request, + response=response, + metadata=metadata, + ) + + # Done; return the response. + return response + async def __aenter__(self) -> "RecommenderAsyncClient": return self diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/client.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/client.py index 27e7d8405061..5c33b3a58bdf 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/client.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/client.py @@ -763,7 +763,7 @@ def sample_get_insight(): google.cloud.recommender_v1beta1.types.Insight: An insight along with the information used to derive the insight. The insight - may have associated recomendations as + may have associated recommendations as well. """ @@ -890,7 +890,7 @@ def sample_mark_insight_accepted(): google.cloud.recommender_v1beta1.types.Insight: An insight along with the information used to derive the insight. The insight - may have associated recomendations as + may have associated recommendations as well. """ @@ -2070,6 +2070,182 @@ def sample_update_insight_type_config(): # Done; return the response. return response + def list_recommenders( + self, + request: Optional[ + Union[recommender_service.ListRecommendersRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListRecommendersPager: + r"""Lists all available Recommenders. + No IAM permissions are required. + + .. 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.cloud import recommender_v1beta1 + + def sample_list_recommenders(): + # Create a client + client = recommender_v1beta1.RecommenderClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListRecommendersRequest( + ) + + # Make the request + page_result = client.list_recommenders(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.recommender_v1beta1.types.ListRecommendersRequest, dict]): + The request object. Request for the ``ListRecommender`` method. + 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.cloud.recommender_v1beta1.services.recommender.pagers.ListRecommendersPager: + Response for the ListRecommender method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # Minor optimization to avoid making a copy if the user passes + # in a recommender_service.ListRecommendersRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, recommender_service.ListRecommendersRequest): + request = recommender_service.ListRecommendersRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_recommenders] + + # 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.ListRecommendersPager( + method=rpc, + request=request, + response=response, + metadata=metadata, + ) + + # Done; return the response. + return response + + def list_insight_types( + self, + request: Optional[ + Union[recommender_service.ListInsightTypesRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListInsightTypesPager: + r"""Lists available InsightTypes. + No IAM permissions are required. + + .. 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.cloud import recommender_v1beta1 + + def sample_list_insight_types(): + # Create a client + client = recommender_v1beta1.RecommenderClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListInsightTypesRequest( + ) + + # Make the request + page_result = client.list_insight_types(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.recommender_v1beta1.types.ListInsightTypesRequest, dict]): + The request object. Request for the ``ListInsightTypes`` method. + 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.cloud.recommender_v1beta1.services.recommender.pagers.ListInsightTypesPager: + Response for the ListInsightTypes method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # Minor optimization to avoid making a copy if the user passes + # in a recommender_service.ListInsightTypesRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, recommender_service.ListInsightTypesRequest): + request = recommender_service.ListInsightTypesRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_insight_types] + + # 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.ListInsightTypesPager( + method=rpc, + request=request, + response=response, + metadata=metadata, + ) + + # Done; return the response. + return response + def __enter__(self) -> "RecommenderClient": return self diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/pagers.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/pagers.py index f4c0a34b66c1..1232c1ce96c5 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/pagers.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/pagers.py @@ -289,3 +289,263 @@ async def async_generator(): def __repr__(self) -> str: return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListRecommendersPager: + """A pager for iterating through ``list_recommenders`` requests. + + This class thinly wraps an initial + :class:`google.cloud.recommender_v1beta1.types.ListRecommendersResponse` object, and + provides an ``__iter__`` method to iterate through its + ``recommenders`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListRecommenders`` requests and continue to iterate + through the ``recommenders`` field on the + corresponding responses. + + All the usual :class:`google.cloud.recommender_v1beta1.types.ListRecommendersResponse` + 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[..., recommender_service.ListRecommendersResponse], + request: recommender_service.ListRecommendersRequest, + response: recommender_service.ListRecommendersResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.recommender_v1beta1.types.ListRecommendersRequest): + The initial request object. + response (google.cloud.recommender_v1beta1.types.ListRecommendersResponse): + 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 = recommender_service.ListRecommendersRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[recommender_service.ListRecommendersResponse]: + 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[recommendation.RecommenderType]: + for page in self.pages: + yield from page.recommenders + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListRecommendersAsyncPager: + """A pager for iterating through ``list_recommenders`` requests. + + This class thinly wraps an initial + :class:`google.cloud.recommender_v1beta1.types.ListRecommendersResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``recommenders`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListRecommenders`` requests and continue to iterate + through the ``recommenders`` field on the + corresponding responses. + + All the usual :class:`google.cloud.recommender_v1beta1.types.ListRecommendersResponse` + 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[recommender_service.ListRecommendersResponse]], + request: recommender_service.ListRecommendersRequest, + response: recommender_service.ListRecommendersResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.recommender_v1beta1.types.ListRecommendersRequest): + The initial request object. + response (google.cloud.recommender_v1beta1.types.ListRecommendersResponse): + 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 = recommender_service.ListRecommendersRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[recommender_service.ListRecommendersResponse]: + 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[recommendation.RecommenderType]: + async def async_generator(): + async for page in self.pages: + for response in page.recommenders: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListInsightTypesPager: + """A pager for iterating through ``list_insight_types`` requests. + + This class thinly wraps an initial + :class:`google.cloud.recommender_v1beta1.types.ListInsightTypesResponse` object, and + provides an ``__iter__`` method to iterate through its + ``insight_types`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListInsightTypes`` requests and continue to iterate + through the ``insight_types`` field on the + corresponding responses. + + All the usual :class:`google.cloud.recommender_v1beta1.types.ListInsightTypesResponse` + 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[..., recommender_service.ListInsightTypesResponse], + request: recommender_service.ListInsightTypesRequest, + response: recommender_service.ListInsightTypesResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.recommender_v1beta1.types.ListInsightTypesRequest): + The initial request object. + response (google.cloud.recommender_v1beta1.types.ListInsightTypesResponse): + 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 = recommender_service.ListInsightTypesRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[recommender_service.ListInsightTypesResponse]: + 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[insight.InsightType]: + for page in self.pages: + yield from page.insight_types + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListInsightTypesAsyncPager: + """A pager for iterating through ``list_insight_types`` requests. + + This class thinly wraps an initial + :class:`google.cloud.recommender_v1beta1.types.ListInsightTypesResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``insight_types`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListInsightTypes`` requests and continue to iterate + through the ``insight_types`` field on the + corresponding responses. + + All the usual :class:`google.cloud.recommender_v1beta1.types.ListInsightTypesResponse` + 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[recommender_service.ListInsightTypesResponse]], + request: recommender_service.ListInsightTypesRequest, + response: recommender_service.ListInsightTypesResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.recommender_v1beta1.types.ListInsightTypesRequest): + The initial request object. + response (google.cloud.recommender_v1beta1.types.ListInsightTypesResponse): + 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 = recommender_service.ListInsightTypesRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[recommender_service.ListInsightTypesResponse]: + 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[insight.InsightType]: + async def async_generator(): + async for page in self.pages: + for response in page.insight_types: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/base.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/base.py index 4f28d6d2c0b5..288c3a3b7507 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/base.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/base.py @@ -232,6 +232,16 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.list_recommenders: gapic_v1.method.wrap_method( + self.list_recommenders, + default_timeout=None, + client_info=client_info, + ), + self.list_insight_types: gapic_v1.method.wrap_method( + self.list_insight_types, + default_timeout=None, + client_info=client_info, + ), } def close(self): @@ -369,6 +379,30 @@ def update_insight_type_config( ]: raise NotImplementedError() + @property + def list_recommenders( + self, + ) -> Callable[ + [recommender_service.ListRecommendersRequest], + Union[ + recommender_service.ListRecommendersResponse, + Awaitable[recommender_service.ListRecommendersResponse], + ], + ]: + raise NotImplementedError() + + @property + def list_insight_types( + self, + ) -> Callable[ + [recommender_service.ListInsightTypesRequest], + Union[ + recommender_service.ListInsightTypesResponse, + Awaitable[recommender_service.ListInsightTypesResponse], + ], + ]: + raise NotImplementedError() + @property def kind(self) -> str: raise NotImplementedError() diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc.py index 0bbc88070480..189f9202b08a 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc.py @@ -632,6 +632,66 @@ def update_insight_type_config( ) return self._stubs["update_insight_type_config"] + @property + def list_recommenders( + self, + ) -> Callable[ + [recommender_service.ListRecommendersRequest], + recommender_service.ListRecommendersResponse, + ]: + r"""Return a callable for the list recommenders method over gRPC. + + Lists all available Recommenders. + No IAM permissions are required. + + Returns: + Callable[[~.ListRecommendersRequest], + ~.ListRecommendersResponse]: + 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_recommenders" not in self._stubs: + self._stubs["list_recommenders"] = self.grpc_channel.unary_unary( + "/google.cloud.recommender.v1beta1.Recommender/ListRecommenders", + request_serializer=recommender_service.ListRecommendersRequest.serialize, + response_deserializer=recommender_service.ListRecommendersResponse.deserialize, + ) + return self._stubs["list_recommenders"] + + @property + def list_insight_types( + self, + ) -> Callable[ + [recommender_service.ListInsightTypesRequest], + recommender_service.ListInsightTypesResponse, + ]: + r"""Return a callable for the list insight types method over gRPC. + + Lists available InsightTypes. + No IAM permissions are required. + + Returns: + Callable[[~.ListInsightTypesRequest], + ~.ListInsightTypesResponse]: + 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_insight_types" not in self._stubs: + self._stubs["list_insight_types"] = self.grpc_channel.unary_unary( + "/google.cloud.recommender.v1beta1.Recommender/ListInsightTypes", + request_serializer=recommender_service.ListInsightTypesRequest.serialize, + response_deserializer=recommender_service.ListInsightTypesResponse.deserialize, + ) + return self._stubs["list_insight_types"] + def close(self): self.grpc_channel.close() diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc_asyncio.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc_asyncio.py index 4c61a88619af..97c2358256b9 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc_asyncio.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/grpc_asyncio.py @@ -638,6 +638,66 @@ def update_insight_type_config( ) return self._stubs["update_insight_type_config"] + @property + def list_recommenders( + self, + ) -> Callable[ + [recommender_service.ListRecommendersRequest], + Awaitable[recommender_service.ListRecommendersResponse], + ]: + r"""Return a callable for the list recommenders method over gRPC. + + Lists all available Recommenders. + No IAM permissions are required. + + Returns: + Callable[[~.ListRecommendersRequest], + Awaitable[~.ListRecommendersResponse]]: + 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_recommenders" not in self._stubs: + self._stubs["list_recommenders"] = self.grpc_channel.unary_unary( + "/google.cloud.recommender.v1beta1.Recommender/ListRecommenders", + request_serializer=recommender_service.ListRecommendersRequest.serialize, + response_deserializer=recommender_service.ListRecommendersResponse.deserialize, + ) + return self._stubs["list_recommenders"] + + @property + def list_insight_types( + self, + ) -> Callable[ + [recommender_service.ListInsightTypesRequest], + Awaitable[recommender_service.ListInsightTypesResponse], + ]: + r"""Return a callable for the list insight types method over gRPC. + + Lists available InsightTypes. + No IAM permissions are required. + + Returns: + Callable[[~.ListInsightTypesRequest], + Awaitable[~.ListInsightTypesResponse]]: + 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_insight_types" not in self._stubs: + self._stubs["list_insight_types"] = self.grpc_channel.unary_unary( + "/google.cloud.recommender.v1beta1.Recommender/ListInsightTypes", + request_serializer=recommender_service.ListInsightTypesRequest.serialize, + response_deserializer=recommender_service.ListInsightTypesResponse.deserialize, + ) + return self._stubs["list_insight_types"] + def close(self): return self.grpc_channel.close() diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/rest.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/rest.py index fa7e2200f169..bde19ed33e6a 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/rest.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/services/recommender/transports/rest.py @@ -113,6 +113,14 @@ def post_list_insights(self, response): logging.log(f"Received response: {response}") return response + def pre_list_insight_types(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_insight_types(self, response): + logging.log(f"Received response: {response}") + return response + def pre_list_recommendations(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -121,6 +129,14 @@ def post_list_recommendations(self, response): logging.log(f"Received response: {response}") return response + def pre_list_recommenders(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_recommenders(self, response): + logging.log(f"Received response: {response}") + return response + def pre_mark_insight_accepted(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -292,6 +308,29 @@ def post_list_insights( """ return response + def pre_list_insight_types( + self, + request: recommender_service.ListInsightTypesRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[recommender_service.ListInsightTypesRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_insight_types + + Override in a subclass to manipulate the request or metadata + before they are sent to the Recommender server. + """ + return request, metadata + + def post_list_insight_types( + self, response: recommender_service.ListInsightTypesResponse + ) -> recommender_service.ListInsightTypesResponse: + """Post-rpc interceptor for list_insight_types + + Override in a subclass to manipulate the response + after it is returned by the Recommender server but before + it is returned to user code. + """ + return response + def pre_list_recommendations( self, request: recommender_service.ListRecommendationsRequest, @@ -317,6 +356,29 @@ def post_list_recommendations( """ return response + def pre_list_recommenders( + self, + request: recommender_service.ListRecommendersRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[recommender_service.ListRecommendersRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_recommenders + + Override in a subclass to manipulate the request or metadata + before they are sent to the Recommender server. + """ + return request, metadata + + def post_list_recommenders( + self, response: recommender_service.ListRecommendersResponse + ) -> recommender_service.ListRecommendersResponse: + """Post-rpc interceptor for list_recommenders + + Override in a subclass to manipulate the response + after it is returned by the Recommender server but before + it is returned to user code. + """ + return response + def pre_mark_insight_accepted( self, request: recommender_service.MarkInsightAcceptedRequest, @@ -604,7 +666,7 @@ def __call__( ~.insight.Insight: An insight along with the information used to derive the insight. The insight - may have associated recomendations as + may have associated recommendations as well. """ @@ -1055,6 +1117,83 @@ def __call__( resp = self._interceptor.post_list_insights(resp) return resp + class _ListInsightTypes(RecommenderRestStub): + def __hash__(self): + return hash("ListInsightTypes") + + def __call__( + self, + request: recommender_service.ListInsightTypesRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> recommender_service.ListInsightTypesResponse: + r"""Call the list insight types method over HTTP. + + Args: + request (~.recommender_service.ListInsightTypesRequest): + The request object. Request for the ``ListInsightTypes`` method. + 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: + ~.recommender_service.ListInsightTypesResponse: + Response for the ``ListInsightTypes`` method. + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1beta1/insightTypes", + }, + ] + request, metadata = self._interceptor.pre_list_insight_types( + request, metadata + ) + pb_request = recommender_service.ListInsightTypesRequest.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"], + including_default_value_fields=False, + use_integers_for_enums=True, + ) + ) + + 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 = recommender_service.ListInsightTypesResponse() + pb_resp = recommender_service.ListInsightTypesResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_insight_types(resp) + return resp + class _ListRecommendations(RecommenderRestStub): def __hash__(self): return hash("ListRecommendations") @@ -1155,6 +1294,83 @@ def __call__( resp = self._interceptor.post_list_recommendations(resp) return resp + class _ListRecommenders(RecommenderRestStub): + def __hash__(self): + return hash("ListRecommenders") + + def __call__( + self, + request: recommender_service.ListRecommendersRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> recommender_service.ListRecommendersResponse: + r"""Call the list recommenders method over HTTP. + + Args: + request (~.recommender_service.ListRecommendersRequest): + The request object. Request for the ``ListRecommender`` method. + 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: + ~.recommender_service.ListRecommendersResponse: + Response for the ``ListRecommender`` method. + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1beta1/recommenders", + }, + ] + request, metadata = self._interceptor.pre_list_recommenders( + request, metadata + ) + pb_request = recommender_service.ListRecommendersRequest.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"], + including_default_value_fields=False, + use_integers_for_enums=True, + ) + ) + + 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 = recommender_service.ListRecommendersResponse() + pb_resp = recommender_service.ListRecommendersResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_recommenders(resp) + return resp + class _MarkInsightAccepted(RecommenderRestStub): def __hash__(self): return hash("MarkInsightAccepted") @@ -1192,7 +1408,7 @@ def __call__( ~.insight.Insight: An insight along with the information used to derive the insight. The insight - may have associated recomendations as + may have associated recommendations as well. """ @@ -1882,6 +2098,17 @@ def list_insights( # In C++ this would require a dynamic_cast return self._ListInsights(self._session, self._host, self._interceptor) # type: ignore + @property + def list_insight_types( + self, + ) -> Callable[ + [recommender_service.ListInsightTypesRequest], + recommender_service.ListInsightTypesResponse, + ]: + # 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._ListInsightTypes(self._session, self._host, self._interceptor) # type: ignore + @property def list_recommendations( self, @@ -1893,6 +2120,17 @@ def list_recommendations( # In C++ this would require a dynamic_cast return self._ListRecommendations(self._session, self._host, self._interceptor) # type: ignore + @property + def list_recommenders( + self, + ) -> Callable[ + [recommender_service.ListRecommendersRequest], + recommender_service.ListRecommendersResponse, + ]: + # 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._ListRecommenders(self._session, self._host, self._interceptor) # type: ignore + @property def mark_insight_accepted( self, diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/__init__.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/__init__.py index 988bea892fb7..42fbddca750c 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/__init__.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/__init__.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # -from .insight import Insight, InsightStateInfo +from .insight import Insight, InsightStateInfo, InsightType from .insight_type_config import InsightTypeConfig, InsightTypeGenerationConfig from .recommendation import ( CostProjection, @@ -23,6 +23,7 @@ Recommendation, RecommendationContent, RecommendationStateInfo, + RecommenderType, SecurityProjection, SustainabilityProjection, ValueMatcher, @@ -35,8 +36,12 @@ GetRecommenderConfigRequest, ListInsightsRequest, ListInsightsResponse, + ListInsightTypesRequest, + ListInsightTypesResponse, ListRecommendationsRequest, ListRecommendationsResponse, + ListRecommendersRequest, + ListRecommendersResponse, MarkInsightAcceptedRequest, MarkRecommendationClaimedRequest, MarkRecommendationFailedRequest, @@ -48,6 +53,7 @@ __all__ = ( "Insight", "InsightStateInfo", + "InsightType", "InsightTypeConfig", "InsightTypeGenerationConfig", "CostProjection", @@ -57,6 +63,7 @@ "Recommendation", "RecommendationContent", "RecommendationStateInfo", + "RecommenderType", "SecurityProjection", "SustainabilityProjection", "ValueMatcher", @@ -68,8 +75,12 @@ "GetRecommenderConfigRequest", "ListInsightsRequest", "ListInsightsResponse", + "ListInsightTypesRequest", + "ListInsightTypesResponse", "ListRecommendationsRequest", "ListRecommendationsResponse", + "ListRecommendersRequest", + "ListRecommendersResponse", "MarkInsightAcceptedRequest", "MarkRecommendationClaimedRequest", "MarkRecommendationFailedRequest", diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/insight.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/insight.py index b428502813f9..a6adc905d1b4 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/insight.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/insight.py @@ -27,13 +27,15 @@ manifest={ "Insight", "InsightStateInfo", + "InsightType", }, ) class Insight(proto.Message): r"""An insight along with the information used to derive the - insight. The insight may have associated recomendations as well. + insight. The insight may have associated recommendations as + well. Attributes: name (str): @@ -238,4 +240,20 @@ class State(proto.Enum): ) +class InsightType(proto.Message): + r"""The type of insight. + + Attributes: + name (str): + The insight_type’s name in format + insightTypes/{insight_type} eg: + insightTypes/google.iam.policy.Insight + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommendation.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommendation.py index 3cac646276e9..94c55d92163e 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommendation.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommendation.py @@ -36,6 +36,7 @@ "SustainabilityProjection", "Impact", "RecommendationStateInfo", + "RecommenderType", }, ) @@ -642,4 +643,20 @@ class State(proto.Enum): ) +class RecommenderType(proto.Message): + r"""The type of a recommender. + + Attributes: + name (str): + The recommender's name in format + RecommenderTypes/{recommender_type} eg: + recommenderTypes/google.iam.policy.Recommender + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommender_service.py b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommender_service.py index 0de1d14d1026..a050abed12be 100644 --- a/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommender_service.py +++ b/packages/google-cloud-recommender/google/cloud/recommender_v1beta1/types/recommender_service.py @@ -46,6 +46,10 @@ "UpdateRecommenderConfigRequest", "GetInsightTypeConfigRequest", "UpdateInsightTypeConfigRequest", + "ListRecommendersRequest", + "ListRecommendersResponse", + "ListInsightTypesRequest", + "ListInsightTypesResponse", }, ) @@ -74,7 +78,7 @@ class ListInsightsRequest(proto.Message): https://cloud.google.com/recommender/docs/insights/insight-types. page_size (int): Optional. The maximum number of results to - return from this request. Non-positive values + return from this request. Non-positive values are ignored. If not specified, the server will determine the number of results to return. page_token (str): @@ -219,7 +223,7 @@ class ListRecommendationsRequest(proto.Message): https://cloud.google.com/recommender/docs/recommenders. page_size (int): Optional. The maximum number of results to - return from this request. Non-positive values + return from this request. Non-positive values are ignored. If not specified, the server will determine the number of results to return. page_token (str): @@ -508,4 +512,104 @@ class UpdateInsightTypeConfigRequest(proto.Message): ) +class ListRecommendersRequest(proto.Message): + r"""Request for the ``ListRecommender`` method. + + Attributes: + page_size (int): + The number of RecommenderTypes to return per + page. The service may return fewer than this + value. + page_token (str): + A page token, received from a previous ``ListRecommenders`` + call. Provide this to retrieve the subsequent page. + """ + + page_size: int = proto.Field( + proto.INT32, + number=1, + ) + page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class ListRecommendersResponse(proto.Message): + r"""Response for the ``ListRecommender`` method. + + Attributes: + recommenders (MutableSequence[google.cloud.recommender_v1beta1.types.RecommenderType]): + The set of recommenders available + next_page_token (str): + A token, which can be sent as ``page_token`` to retrieve the + next page. If this field is omitted, there are no subsequent + pages. + """ + + @property + def raw_page(self): + return self + + recommenders: MutableSequence[recommendation.RecommenderType] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=recommendation.RecommenderType, + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class ListInsightTypesRequest(proto.Message): + r"""Request for the ``ListInsightTypes`` method. + + Attributes: + page_size (int): + The number of InsightTypes to return per + page. The service may return fewer than this + value. + page_token (str): + A page token, received from a previous ``ListRecommenders`` + call. Provide this to retrieve the subsequent page. + """ + + page_size: int = proto.Field( + proto.INT32, + number=1, + ) + page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class ListInsightTypesResponse(proto.Message): + r"""Response for the ``ListInsightTypes`` method. + + Attributes: + insight_types (MutableSequence[google.cloud.recommender_v1beta1.types.InsightType]): + The set of recommenders available + next_page_token (str): + A token, which can be sent as ``page_token`` to retrieve the + next page. If this field is omitted, there are no subsequent + pages. + """ + + @property + def raw_page(self): + return self + + insight_types: MutableSequence[insight.InsightType] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=insight.InsightType, + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_insight_types_async.py b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_insight_types_async.py new file mode 100644 index 000000000000..28ed580ef7ef --- /dev/null +++ b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_insight_types_async.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2023 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 ListInsightTypes +# 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-cloud-recommender + + +# [START recommender_v1beta1_generated_Recommender_ListInsightTypes_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.cloud import recommender_v1beta1 + + +async def sample_list_insight_types(): + # Create a client + client = recommender_v1beta1.RecommenderAsyncClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListInsightTypesRequest( + ) + + # Make the request + page_result = client.list_insight_types(request=request) + + # Handle the response + async for response in page_result: + print(response) + +# [END recommender_v1beta1_generated_Recommender_ListInsightTypes_async] diff --git a/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_insight_types_sync.py b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_insight_types_sync.py new file mode 100644 index 000000000000..d93b751f8a08 --- /dev/null +++ b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_insight_types_sync.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2023 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 ListInsightTypes +# 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-cloud-recommender + + +# [START recommender_v1beta1_generated_Recommender_ListInsightTypes_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.cloud import recommender_v1beta1 + + +def sample_list_insight_types(): + # Create a client + client = recommender_v1beta1.RecommenderClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListInsightTypesRequest( + ) + + # Make the request + page_result = client.list_insight_types(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END recommender_v1beta1_generated_Recommender_ListInsightTypes_sync] diff --git a/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_recommenders_async.py b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_recommenders_async.py new file mode 100644 index 000000000000..79d8fdad49b8 --- /dev/null +++ b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_recommenders_async.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2023 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 ListRecommenders +# 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-cloud-recommender + + +# [START recommender_v1beta1_generated_Recommender_ListRecommenders_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.cloud import recommender_v1beta1 + + +async def sample_list_recommenders(): + # Create a client + client = recommender_v1beta1.RecommenderAsyncClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListRecommendersRequest( + ) + + # Make the request + page_result = client.list_recommenders(request=request) + + # Handle the response + async for response in page_result: + print(response) + +# [END recommender_v1beta1_generated_Recommender_ListRecommenders_async] diff --git a/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_recommenders_sync.py b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_recommenders_sync.py new file mode 100644 index 000000000000..ba08be6e8aea --- /dev/null +++ b/packages/google-cloud-recommender/samples/generated_samples/recommender_v1beta1_generated_recommender_list_recommenders_sync.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2023 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 ListRecommenders +# 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-cloud-recommender + + +# [START recommender_v1beta1_generated_Recommender_ListRecommenders_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.cloud import recommender_v1beta1 + + +def sample_list_recommenders(): + # Create a client + client = recommender_v1beta1.RecommenderClient() + + # Initialize request argument(s) + request = recommender_v1beta1.ListRecommendersRequest( + ) + + # Make the request + page_result = client.list_recommenders(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END recommender_v1beta1_generated_Recommender_ListRecommenders_sync] diff --git a/packages/google-cloud-recommender/samples/generated_samples/snippet_metadata_google.cloud.recommender.v1beta1.json b/packages/google-cloud-recommender/samples/generated_samples/snippet_metadata_google.cloud.recommender.v1beta1.json index fd53d49a9486..e4ff805e99aa 100644 --- a/packages/google-cloud-recommender/samples/generated_samples/snippet_metadata_google.cloud.recommender.v1beta1.json +++ b/packages/google-cloud-recommender/samples/generated_samples/snippet_metadata_google.cloud.recommender.v1beta1.json @@ -655,6 +655,159 @@ ], "title": "recommender_v1beta1_generated_recommender_get_recommender_config_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.recommender_v1beta1.RecommenderAsyncClient", + "shortName": "RecommenderAsyncClient" + }, + "fullName": "google.cloud.recommender_v1beta1.RecommenderAsyncClient.list_insight_types", + "method": { + "fullName": "google.cloud.recommender.v1beta1.Recommender.ListInsightTypes", + "service": { + "fullName": "google.cloud.recommender.v1beta1.Recommender", + "shortName": "Recommender" + }, + "shortName": "ListInsightTypes" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.recommender_v1beta1.types.ListInsightTypesRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.recommender_v1beta1.services.recommender.pagers.ListInsightTypesAsyncPager", + "shortName": "list_insight_types" + }, + "description": "Sample for ListInsightTypes", + "file": "recommender_v1beta1_generated_recommender_list_insight_types_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "recommender_v1beta1_generated_Recommender_ListInsightTypes_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 47, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 48, + "type": "RESPONSE_HANDLING" + } + ], + "title": "recommender_v1beta1_generated_recommender_list_insight_types_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.recommender_v1beta1.RecommenderClient", + "shortName": "RecommenderClient" + }, + "fullName": "google.cloud.recommender_v1beta1.RecommenderClient.list_insight_types", + "method": { + "fullName": "google.cloud.recommender.v1beta1.Recommender.ListInsightTypes", + "service": { + "fullName": "google.cloud.recommender.v1beta1.Recommender", + "shortName": "Recommender" + }, + "shortName": "ListInsightTypes" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.recommender_v1beta1.types.ListInsightTypesRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.recommender_v1beta1.services.recommender.pagers.ListInsightTypesPager", + "shortName": "list_insight_types" + }, + "description": "Sample for ListInsightTypes", + "file": "recommender_v1beta1_generated_recommender_list_insight_types_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "recommender_v1beta1_generated_Recommender_ListInsightTypes_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 47, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 48, + "type": "RESPONSE_HANDLING" + } + ], + "title": "recommender_v1beta1_generated_recommender_list_insight_types_sync.py" + }, { "canonical": true, "clientMethod": { @@ -985,6 +1138,159 @@ ], "title": "recommender_v1beta1_generated_recommender_list_recommendations_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.recommender_v1beta1.RecommenderAsyncClient", + "shortName": "RecommenderAsyncClient" + }, + "fullName": "google.cloud.recommender_v1beta1.RecommenderAsyncClient.list_recommenders", + "method": { + "fullName": "google.cloud.recommender.v1beta1.Recommender.ListRecommenders", + "service": { + "fullName": "google.cloud.recommender.v1beta1.Recommender", + "shortName": "Recommender" + }, + "shortName": "ListRecommenders" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.recommender_v1beta1.types.ListRecommendersRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.recommender_v1beta1.services.recommender.pagers.ListRecommendersAsyncPager", + "shortName": "list_recommenders" + }, + "description": "Sample for ListRecommenders", + "file": "recommender_v1beta1_generated_recommender_list_recommenders_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "recommender_v1beta1_generated_Recommender_ListRecommenders_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 47, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 48, + "type": "RESPONSE_HANDLING" + } + ], + "title": "recommender_v1beta1_generated_recommender_list_recommenders_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.recommender_v1beta1.RecommenderClient", + "shortName": "RecommenderClient" + }, + "fullName": "google.cloud.recommender_v1beta1.RecommenderClient.list_recommenders", + "method": { + "fullName": "google.cloud.recommender.v1beta1.Recommender.ListRecommenders", + "service": { + "fullName": "google.cloud.recommender.v1beta1.Recommender", + "shortName": "Recommender" + }, + "shortName": "ListRecommenders" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.recommender_v1beta1.types.ListRecommendersRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.recommender_v1beta1.services.recommender.pagers.ListRecommendersPager", + "shortName": "list_recommenders" + }, + "description": "Sample for ListRecommenders", + "file": "recommender_v1beta1_generated_recommender_list_recommenders_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "recommender_v1beta1_generated_Recommender_ListRecommenders_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 47, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 48, + "type": "RESPONSE_HANDLING" + } + ], + "title": "recommender_v1beta1_generated_recommender_list_recommenders_sync.py" + }, { "canonical": true, "clientMethod": { diff --git a/packages/google-cloud-recommender/scripts/fixup_recommender_v1beta1_keywords.py b/packages/google-cloud-recommender/scripts/fixup_recommender_v1beta1_keywords.py index 51142e4a54f5..d4b6d4eb84e4 100644 --- a/packages/google-cloud-recommender/scripts/fixup_recommender_v1beta1_keywords.py +++ b/packages/google-cloud-recommender/scripts/fixup_recommender_v1beta1_keywords.py @@ -44,7 +44,9 @@ class recommenderCallTransformer(cst.CSTTransformer): 'get_recommendation': ('name', ), 'get_recommender_config': ('name', ), 'list_insights': ('parent', 'page_size', 'page_token', 'filter', ), + 'list_insight_types': ('page_size', 'page_token', ), 'list_recommendations': ('parent', 'page_size', 'page_token', 'filter', ), + 'list_recommenders': ('page_size', 'page_token', ), 'mark_insight_accepted': ('name', 'etag', 'state_metadata', ), 'mark_recommendation_claimed': ('name', 'etag', 'state_metadata', ), 'mark_recommendation_failed': ('name', 'etag', 'state_metadata', ), diff --git a/packages/google-cloud-recommender/tests/unit/gapic/recommender_v1beta1/test_recommender.py b/packages/google-cloud-recommender/tests/unit/gapic/recommender_v1beta1/test_recommender.py index ff2fa85e6ef9..562a4af28682 100644 --- a/packages/google-cloud-recommender/tests/unit/gapic/recommender_v1beta1/test_recommender.py +++ b/packages/google-cloud-recommender/tests/unit/gapic/recommender_v1beta1/test_recommender.py @@ -4310,6 +4310,588 @@ async def test_update_insight_type_config_flattened_error_async(): ) +@pytest.mark.parametrize( + "request_type", + [ + recommender_service.ListRecommendersRequest, + dict, + ], +) +def test_list_recommenders(request_type, transport: str = "grpc"): + client = RecommenderClient( + 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() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_recommenders), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = recommender_service.ListRecommendersResponse( + next_page_token="next_page_token_value", + ) + response = client.list_recommenders(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == recommender_service.ListRecommendersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListRecommendersPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_recommenders_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 = RecommenderClient( + 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_recommenders), "__call__" + ) as call: + client.list_recommenders() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == recommender_service.ListRecommendersRequest() + + +@pytest.mark.asyncio +async def test_list_recommenders_async( + transport: str = "grpc_asyncio", + request_type=recommender_service.ListRecommendersRequest, +): + client = RecommenderAsyncClient( + 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() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_recommenders), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + recommender_service.ListRecommendersResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_recommenders(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == recommender_service.ListRecommendersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListRecommendersAsyncPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.asyncio +async def test_list_recommenders_async_from_dict(): + await test_list_recommenders_async(request_type=dict) + + +def test_list_recommenders_pager(transport_name: str = "grpc"): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials, + transport=transport_name, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_recommenders), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + next_page_token="abc", + ), + recommender_service.ListRecommendersResponse( + recommenders=[], + next_page_token="def", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + ], + next_page_token="ghi", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + ), + RuntimeError, + ) + + metadata = () + pager = client.list_recommenders(request={}) + + assert pager._metadata == metadata + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, recommendation.RecommenderType) for i in results) + + +def test_list_recommenders_pages(transport_name: str = "grpc"): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials, + transport=transport_name, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_recommenders), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + next_page_token="abc", + ), + recommender_service.ListRecommendersResponse( + recommenders=[], + next_page_token="def", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + ], + next_page_token="ghi", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + ), + RuntimeError, + ) + pages = list(client.list_recommenders(request={}).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.asyncio +async def test_list_recommenders_async_pager(): + client = RecommenderAsyncClient( + credentials=ga_credentials.AnonymousCredentials, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_recommenders), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + next_page_token="abc", + ), + recommender_service.ListRecommendersResponse( + recommenders=[], + next_page_token="def", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + ], + next_page_token="ghi", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + ), + RuntimeError, + ) + async_pager = await client.list_recommenders( + request={}, + ) + 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, recommendation.RecommenderType) for i in responses) + + +@pytest.mark.asyncio +async def test_list_recommenders_async_pages(): + client = RecommenderAsyncClient( + credentials=ga_credentials.AnonymousCredentials, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_recommenders), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + next_page_token="abc", + ), + recommender_service.ListRecommendersResponse( + recommenders=[], + next_page_token="def", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + ], + next_page_token="ghi", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + ), + RuntimeError, + ) + 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_recommenders(request={}) + ).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + recommender_service.ListInsightTypesRequest, + dict, + ], +) +def test_list_insight_types(request_type, transport: str = "grpc"): + client = RecommenderClient( + 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() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_insight_types), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = recommender_service.ListInsightTypesResponse( + next_page_token="next_page_token_value", + ) + response = client.list_insight_types(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == recommender_service.ListInsightTypesRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListInsightTypesPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_insight_types_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 = RecommenderClient( + 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_insight_types), "__call__" + ) as call: + client.list_insight_types() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == recommender_service.ListInsightTypesRequest() + + +@pytest.mark.asyncio +async def test_list_insight_types_async( + transport: str = "grpc_asyncio", + request_type=recommender_service.ListInsightTypesRequest, +): + client = RecommenderAsyncClient( + 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() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_insight_types), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + recommender_service.ListInsightTypesResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_insight_types(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == recommender_service.ListInsightTypesRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListInsightTypesAsyncPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.asyncio +async def test_list_insight_types_async_from_dict(): + await test_list_insight_types_async(request_type=dict) + + +def test_list_insight_types_pager(transport_name: str = "grpc"): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials, + transport=transport_name, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_insight_types), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + insight.InsightType(), + ], + next_page_token="abc", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[], + next_page_token="def", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + ], + next_page_token="ghi", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + ], + ), + RuntimeError, + ) + + metadata = () + pager = client.list_insight_types(request={}) + + assert pager._metadata == metadata + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, insight.InsightType) for i in results) + + +def test_list_insight_types_pages(transport_name: str = "grpc"): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials, + transport=transport_name, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_insight_types), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + insight.InsightType(), + ], + next_page_token="abc", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[], + next_page_token="def", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + ], + next_page_token="ghi", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + ], + ), + RuntimeError, + ) + pages = list(client.list_insight_types(request={}).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.asyncio +async def test_list_insight_types_async_pager(): + client = RecommenderAsyncClient( + credentials=ga_credentials.AnonymousCredentials, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_insight_types), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + insight.InsightType(), + ], + next_page_token="abc", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[], + next_page_token="def", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + ], + next_page_token="ghi", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + ], + ), + RuntimeError, + ) + async_pager = await client.list_insight_types( + request={}, + ) + 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, insight.InsightType) for i in responses) + + +@pytest.mark.asyncio +async def test_list_insight_types_async_pages(): + client = RecommenderAsyncClient( + credentials=ga_credentials.AnonymousCredentials, + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_insight_types), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + insight.InsightType(), + ], + next_page_token="abc", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[], + next_page_token="def", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + ], + next_page_token="ghi", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + ], + ), + RuntimeError, + ) + 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_insight_types(request={}) + ).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + @pytest.mark.parametrize( "request_type", [ @@ -4317,45 +4899,690 @@ async def test_update_insight_type_config_flattened_error_async(): dict, ], ) -def test_list_insights_rest(request_type): +def test_list_insights_rest(request_type): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/insightTypes/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 = recommender_service.ListInsightsResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = recommender_service.ListInsightsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_insights(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListInsightsPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_insights_rest_required_fields( + request_type=recommender_service.ListInsightsRequest, +): + transport_class = transports.RecommenderRestTransport + + 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, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_insights._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_insights._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 "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = recommender_service.ListInsightsResponse() + # 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 + + pb_return_value = recommender_service.ListInsightsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_insights(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_insights_rest_unset_required_fields(): + transport = transports.RecommenderRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_insights._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_insights_rest_interceptors(null_interceptor): + transport = transports.RecommenderRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.RecommenderRestInterceptor(), + ) + client = RecommenderClient(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.RecommenderRestInterceptor, "post_list_insights" + ) as post, mock.patch.object( + transports.RecommenderRestInterceptor, "pre_list_insights" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = recommender_service.ListInsightsRequest.pb( + recommender_service.ListInsightsRequest() + ) + 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 = recommender_service.ListInsightsResponse.to_json( + recommender_service.ListInsightsResponse() + ) + + request = recommender_service.ListInsightsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = recommender_service.ListInsightsResponse() + + client.list_insights( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_insights_rest_bad_request( + transport: str = "rest", request_type=recommender_service.ListInsightsRequest +): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/insightTypes/sample3"} + 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_insights(request) + + +def test_list_insights_rest_flattened(): + client = RecommenderClient( + 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 = recommender_service.ListInsightsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/insightTypes/sample3" + } + + # 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 + pb_return_value = recommender_service.ListInsightsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_insights(**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/v1beta1/{parent=projects/*/locations/*/insightTypes/*}/insights" + % client.transport._host, + args[1], + ) + + +def test_list_insights_rest_flattened_error(transport: str = "rest"): + client = RecommenderClient( + 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_insights( + recommender_service.ListInsightsRequest(), + parent="parent_value", + ) + + +def test_list_insights_rest_pager(transport: str = "rest"): + client = RecommenderClient( + 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 = ( + recommender_service.ListInsightsResponse( + insights=[ + insight.Insight(), + insight.Insight(), + insight.Insight(), + ], + next_page_token="abc", + ), + recommender_service.ListInsightsResponse( + insights=[], + next_page_token="def", + ), + recommender_service.ListInsightsResponse( + insights=[ + insight.Insight(), + ], + next_page_token="ghi", + ), + recommender_service.ListInsightsResponse( + insights=[ + insight.Insight(), + insight.Insight(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + recommender_service.ListInsightsResponse.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": "projects/sample1/locations/sample2/insightTypes/sample3" + } + + pager = client.list_insights(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, insight.Insight) for i in results) + + pages = list(client.list_insights(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", + [ + recommender_service.GetInsightRequest, + dict, + ], +) +def test_get_insight_rest(request_type): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + } + 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 = insight.Insight( + name="name_value", + description="description_value", + target_resources=["target_resources_value"], + insight_subtype="insight_subtype_value", + category=insight.Insight.Category.COST, + severity=insight.Insight.Severity.LOW, + etag="etag_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = insight.Insight.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_insight(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, insight.Insight) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.target_resources == ["target_resources_value"] + assert response.insight_subtype == "insight_subtype_value" + assert response.category == insight.Insight.Category.COST + assert response.severity == insight.Insight.Severity.LOW + assert response.etag == "etag_value" + + +def test_get_insight_rest_required_fields( + request_type=recommender_service.GetInsightRequest, +): + transport_class = transports.RecommenderRestTransport + + 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, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_insight._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_insight._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 = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = insight.Insight() + # 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 + + pb_return_value = insight.Insight.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_insight(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_insight_rest_unset_required_fields(): + transport = transports.RecommenderRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_insight._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_insight_rest_interceptors(null_interceptor): + transport = transports.RecommenderRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.RecommenderRestInterceptor(), + ) + client = RecommenderClient(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.RecommenderRestInterceptor, "post_get_insight" + ) as post, mock.patch.object( + transports.RecommenderRestInterceptor, "pre_get_insight" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = recommender_service.GetInsightRequest.pb( + recommender_service.GetInsightRequest() + ) + 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 = insight.Insight.to_json(insight.Insight()) + + request = recommender_service.GetInsightRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = insight.Insight() + + client.get_insight( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_insight_rest_bad_request( + transport: str = "rest", request_type=recommender_service.GetInsightRequest +): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + } + 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.get_insight(request) + + +def test_get_insight_rest_flattened(): + client = RecommenderClient( + 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 = insight.Insight() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + } + + # 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 + pb_return_value = insight.Insight.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_insight(**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/v1beta1/{name=projects/*/locations/*/insightTypes/*/insights/*}" + % client.transport._host, + args[1], + ) + + +def test_get_insight_rest_flattened_error(transport: str = "rest"): + client = RecommenderClient( + 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_insight( + recommender_service.GetInsightRequest(), + name="name_value", + ) + + +def test_get_insight_rest_error(): + client = RecommenderClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + recommender_service.MarkInsightAcceptedRequest, + dict, + ], +) +def test_mark_insight_accepted_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/insightTypes/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + } 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 = recommender_service.ListInsightsResponse( - next_page_token="next_page_token_value", + return_value = insight.Insight( + name="name_value", + description="description_value", + target_resources=["target_resources_value"], + insight_subtype="insight_subtype_value", + category=insight.Insight.Category.COST, + severity=insight.Insight.Severity.LOW, + etag="etag_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_service.ListInsightsResponse.pb(return_value) + pb_return_value = insight.Insight.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.list_insights(request) + response = client.mark_insight_accepted(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListInsightsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, insight.Insight) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.target_resources == ["target_resources_value"] + assert response.insight_subtype == "insight_subtype_value" + assert response.category == insight.Insight.Category.COST + assert response.severity == insight.Insight.Severity.LOW + assert response.etag == "etag_value" -def test_list_insights_rest_required_fields( - request_type=recommender_service.ListInsightsRequest, +def test_mark_insight_accepted_rest_required_fields( + request_type=recommender_service.MarkInsightAcceptedRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" + request_init["etag"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -4370,29 +5597,24 @@ def test_list_insights_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_insights._get_unset_required_fields(jsonified_request) + ).mark_insight_accepted._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" + jsonified_request["etag"] = "etag_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_insights._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", - ) - ) + ).mark_insight_accepted._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" + assert "etag" in jsonified_request + assert jsonified_request["etag"] == "etag_value" client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4401,7 +5623,7 @@ def test_list_insights_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = recommender_service.ListInsightsResponse() + return_value = insight.Insight() # 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 @@ -4413,47 +5635,47 @@ def test_list_insights_rest_required_fields( 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() response_value.status_code = 200 - pb_return_value = recommender_service.ListInsightsResponse.pb(return_value) + pb_return_value = insight.Insight.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.list_insights(request) + response = client.mark_insight_accepted(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_insights_rest_unset_required_fields(): +def test_mark_insight_accepted_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_insights._get_unset_required_fields({}) + unset_fields = transport.mark_insight_accepted._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "filter", - "pageSize", - "pageToken", + "name", + "etag", ) ) - & set(("parent",)) ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_insights_rest_interceptors(null_interceptor): +def test_mark_insight_accepted_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -4466,14 +5688,14 @@ def test_list_insights_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_list_insights" + transports.RecommenderRestInterceptor, "post_mark_insight_accepted" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_list_insights" + transports.RecommenderRestInterceptor, "pre_mark_insight_accepted" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.ListInsightsRequest.pb( - recommender_service.ListInsightsRequest() + pb_message = recommender_service.MarkInsightAcceptedRequest.pb( + recommender_service.MarkInsightAcceptedRequest() ) transcode.return_value = { "method": "post", @@ -4485,19 +5707,17 @@ def test_list_insights_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = recommender_service.ListInsightsResponse.to_json( - recommender_service.ListInsightsResponse() - ) + req.return_value._content = insight.Insight.to_json(insight.Insight()) - request = recommender_service.ListInsightsRequest() + request = recommender_service.MarkInsightAcceptedRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = recommender_service.ListInsightsResponse() + post.return_value = insight.Insight() - client.list_insights( + client.mark_insight_accepted( request, metadata=[ ("key", "val"), @@ -4509,8 +5729,8 @@ def test_list_insights_rest_interceptors(null_interceptor): post.assert_called_once() -def test_list_insights_rest_bad_request( - transport: str = "rest", request_type=recommender_service.ListInsightsRequest +def test_mark_insight_accepted_rest_bad_request( + transport: str = "rest", request_type=recommender_service.MarkInsightAcceptedRequest ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4518,7 +5738,9 @@ def test_list_insights_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/insightTypes/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -4530,10 +5752,10 @@ def test_list_insights_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.list_insights(request) + client.mark_insight_accepted(request) -def test_list_insights_rest_flattened(): +def test_mark_insight_accepted_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -4542,41 +5764,43 @@ def test_list_insights_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 = recommender_service.ListInsightsResponse() + return_value = insight.Insight() # get arguments that satisfy an http rule for this method sample_request = { - "parent": "projects/sample1/locations/sample2/insightTypes/sample3" + "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", + state_metadata={"key_value": "value_value"}, + etag="etag_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_service.ListInsightsResponse.pb(return_value) + pb_return_value = insight.Insight.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.list_insights(**mock_args) + client.mark_insight_accepted(**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/v1beta1/{parent=projects/*/locations/*/insightTypes/*}/insights" + "%s/v1beta1/{name=projects/*/locations/*/insightTypes/*/insights/*}:markAccepted" % client.transport._host, args[1], ) -def test_list_insights_rest_flattened_error(transport: str = "rest"): +def test_mark_insight_accepted_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -4585,137 +5809,68 @@ def test_list_insights_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_insights( - recommender_service.ListInsightsRequest(), - parent="parent_value", + client.mark_insight_accepted( + recommender_service.MarkInsightAcceptedRequest(), + name="name_value", + state_metadata={"key_value": "value_value"}, + etag="etag_value", ) -def test_list_insights_rest_pager(transport: str = "rest"): +def test_mark_insight_accepted_rest_error(): client = RecommenderClient( - 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 = ( - recommender_service.ListInsightsResponse( - insights=[ - insight.Insight(), - insight.Insight(), - insight.Insight(), - ], - next_page_token="abc", - ), - recommender_service.ListInsightsResponse( - insights=[], - next_page_token="def", - ), - recommender_service.ListInsightsResponse( - insights=[ - insight.Insight(), - ], - next_page_token="ghi", - ), - recommender_service.ListInsightsResponse( - insights=[ - insight.Insight(), - insight.Insight(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - recommender_service.ListInsightsResponse.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": "projects/sample1/locations/sample2/insightTypes/sample3" - } - - pager = client.list_insights(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, insight.Insight) for i in results) - - pages = list(client.list_insights(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", [ - recommender_service.GetInsightRequest, + recommender_service.ListRecommendationsRequest, dict, ], ) -def test_get_insight_rest(request_type): +def test_list_recommendations_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" - } + request_init = {"parent": "projects/sample1/locations/sample2/recommenders/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 = insight.Insight( - name="name_value", - description="description_value", - target_resources=["target_resources_value"], - insight_subtype="insight_subtype_value", - category=insight.Insight.Category.COST, - severity=insight.Insight.Severity.LOW, - etag="etag_value", + return_value = recommender_service.ListRecommendationsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = insight.Insight.pb(return_value) + pb_return_value = recommender_service.ListRecommendationsResponse.pb( + return_value + ) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_insight(request) + response = client.list_recommendations(request) # Establish that the response is the type that we expect. - assert isinstance(response, insight.Insight) - assert response.name == "name_value" - assert response.description == "description_value" - assert response.target_resources == ["target_resources_value"] - assert response.insight_subtype == "insight_subtype_value" - assert response.category == insight.Insight.Category.COST - assert response.severity == insight.Insight.Severity.LOW - assert response.etag == "etag_value" + assert isinstance(response, pagers.ListRecommendationsPager) + assert response.next_page_token == "next_page_token_value" -def test_get_insight_rest_required_fields( - request_type=recommender_service.GetInsightRequest, +def test_list_recommendations_rest_required_fields( + request_type=recommender_service.ListRecommendationsRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -4730,21 +5885,29 @@ def test_get_insight_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_insight._get_unset_required_fields(jsonified_request) + ).list_recommendations._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() - ).get_insight._get_unset_required_fields(jsonified_request) + ).list_recommendations._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 = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4753,7 +5916,7 @@ def test_get_insight_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = insight.Insight() + return_value = recommender_service.ListRecommendationsResponse() # 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 @@ -4773,30 +5936,41 @@ def test_get_insight_rest_required_fields( response_value = Response() response_value.status_code = 200 - pb_return_value = insight.Insight.pb(return_value) + pb_return_value = recommender_service.ListRecommendationsResponse.pb( + return_value + ) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_insight(request) + response = client.list_recommendations(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_insight_rest_unset_required_fields(): +def test_list_recommendations_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_insight._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.list_recommendations._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_insight_rest_interceptors(null_interceptor): +def test_list_recommendations_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -4809,14 +5983,14 @@ def test_get_insight_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_get_insight" + transports.RecommenderRestInterceptor, "post_list_recommendations" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_get_insight" + transports.RecommenderRestInterceptor, "pre_list_recommendations" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.GetInsightRequest.pb( - recommender_service.GetInsightRequest() + pb_message = recommender_service.ListRecommendationsRequest.pb( + recommender_service.ListRecommendationsRequest() ) transcode.return_value = { "method": "post", @@ -4828,17 +6002,21 @@ def test_get_insight_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = insight.Insight.to_json(insight.Insight()) + req.return_value._content = ( + recommender_service.ListRecommendationsResponse.to_json( + recommender_service.ListRecommendationsResponse() + ) + ) - request = recommender_service.GetInsightRequest() + request = recommender_service.ListRecommendationsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = insight.Insight() + post.return_value = recommender_service.ListRecommendationsResponse() - client.get_insight( + client.list_recommendations( request, metadata=[ ("key", "val"), @@ -4850,8 +6028,8 @@ def test_get_insight_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_insight_rest_bad_request( - transport: str = "rest", request_type=recommender_service.GetInsightRequest +def test_list_recommendations_rest_bad_request( + transport: str = "rest", request_type=recommender_service.ListRecommendationsRequest ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4859,9 +6037,7 @@ def test_get_insight_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" - } + request_init = {"parent": "projects/sample1/locations/sample2/recommenders/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -4873,10 +6049,10 @@ def test_get_insight_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_insight(request) + client.list_recommendations(request) -def test_get_insight_rest_flattened(): +def test_list_recommendations_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -4885,41 +6061,44 @@ def test_get_insight_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 = insight.Insight() + return_value = recommender_service.ListRecommendationsResponse() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + "parent": "projects/sample1/locations/sample2/recommenders/sample3" } # get truthy value for each flattened field mock_args = dict( - name="name_value", + 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 - pb_return_value = insight.Insight.pb(return_value) + pb_return_value = recommender_service.ListRecommendationsResponse.pb( + return_value + ) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_insight(**mock_args) + client.list_recommendations(**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/v1beta1/{name=projects/*/locations/*/insightTypes/*/insights/*}" + "%s/v1beta1/{parent=projects/*/locations/*/recommenders/*}/recommendations" % client.transport._host, args[1], ) -def test_get_insight_rest_flattened_error(transport: str = "rest"): +def test_list_recommendations_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -4928,26 +6107,86 @@ def test_get_insight_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_insight( - recommender_service.GetInsightRequest(), - name="name_value", + client.list_recommendations( + recommender_service.ListRecommendationsRequest(), + parent="parent_value", + filter="filter_value", ) -def test_get_insight_rest_error(): +def test_list_recommendations_rest_pager(transport: str = "rest"): client = RecommenderClient( - 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 = ( + recommender_service.ListRecommendationsResponse( + recommendations=[ + recommendation.Recommendation(), + recommendation.Recommendation(), + recommendation.Recommendation(), + ], + next_page_token="abc", + ), + recommender_service.ListRecommendationsResponse( + recommendations=[], + next_page_token="def", + ), + recommender_service.ListRecommendationsResponse( + recommendations=[ + recommendation.Recommendation(), + ], + next_page_token="ghi", + ), + recommender_service.ListRecommendationsResponse( + recommendations=[ + recommendation.Recommendation(), + recommendation.Recommendation(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + recommender_service.ListRecommendationsResponse.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": "projects/sample1/locations/sample2/recommenders/sample3" + } + + pager = client.list_recommendations(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, recommendation.Recommendation) for i in results) + + pages = list(client.list_recommendations(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", [ - recommender_service.MarkInsightAcceptedRequest, + recommender_service.GetRecommendationRequest, dict, ], ) -def test_mark_insight_accepted_rest(request_type): +def test_get_recommendation_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -4955,52 +6194,49 @@ def test_mark_insight_accepted_rest(request_type): # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" } 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 = insight.Insight( + return_value = recommendation.Recommendation( name="name_value", description="description_value", - target_resources=["target_resources_value"], - insight_subtype="insight_subtype_value", - category=insight.Insight.Category.COST, - severity=insight.Insight.Severity.LOW, + recommender_subtype="recommender_subtype_value", + priority=recommendation.Recommendation.Priority.P4, etag="etag_value", + xor_group_id="xor_group_id_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = insight.Insight.pb(return_value) + pb_return_value = recommendation.Recommendation.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_insight_accepted(request) + response = client.get_recommendation(request) # Establish that the response is the type that we expect. - assert isinstance(response, insight.Insight) + assert isinstance(response, recommendation.Recommendation) assert response.name == "name_value" assert response.description == "description_value" - assert response.target_resources == ["target_resources_value"] - assert response.insight_subtype == "insight_subtype_value" - assert response.category == insight.Insight.Category.COST - assert response.severity == insight.Insight.Severity.LOW + assert response.recommender_subtype == "recommender_subtype_value" + assert response.priority == recommendation.Recommendation.Priority.P4 assert response.etag == "etag_value" + assert response.xor_group_id == "xor_group_id_value" -def test_mark_insight_accepted_rest_required_fields( - request_type=recommender_service.MarkInsightAcceptedRequest, +def test_get_recommendation_rest_required_fields( + request_type=recommender_service.GetRecommendationRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} request_init["name"] = "" - request_init["etag"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -5015,24 +6251,21 @@ def test_mark_insight_accepted_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_insight_accepted._get_unset_required_fields(jsonified_request) + ).get_recommendation._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["etag"] = "etag_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_insight_accepted._get_unset_required_fields(jsonified_request) + ).get_recommendation._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 "etag" in jsonified_request - assert jsonified_request["etag"] == "etag_value" client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5041,7 +6274,7 @@ def test_mark_insight_accepted_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = insight.Insight() + return_value = recommendation.Recommendation() # 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 @@ -5053,47 +6286,38 @@ def test_mark_insight_accepted_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - pb_return_value = insight.Insight.pb(return_value) + pb_return_value = recommendation.Recommendation.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_insight_accepted(request) + response = client.get_recommendation(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_mark_insight_accepted_rest_unset_required_fields(): +def test_get_recommendation_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.mark_insight_accepted._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "name", - "etag", - ) - ) - ) + unset_fields = transport.get_recommendation._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_mark_insight_accepted_rest_interceptors(null_interceptor): +def test_get_recommendation_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -5106,14 +6330,14 @@ def test_mark_insight_accepted_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_mark_insight_accepted" + transports.RecommenderRestInterceptor, "post_get_recommendation" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_mark_insight_accepted" + transports.RecommenderRestInterceptor, "pre_get_recommendation" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.MarkInsightAcceptedRequest.pb( - recommender_service.MarkInsightAcceptedRequest() + pb_message = recommender_service.GetRecommendationRequest.pb( + recommender_service.GetRecommendationRequest() ) transcode.return_value = { "method": "post", @@ -5125,17 +6349,19 @@ def test_mark_insight_accepted_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = insight.Insight.to_json(insight.Insight()) + req.return_value._content = recommendation.Recommendation.to_json( + recommendation.Recommendation() + ) - request = recommender_service.MarkInsightAcceptedRequest() + request = recommender_service.GetRecommendationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = insight.Insight() + post.return_value = recommendation.Recommendation() - client.mark_insight_accepted( + client.get_recommendation( request, metadata=[ ("key", "val"), @@ -5147,8 +6373,8 @@ def test_mark_insight_accepted_rest_interceptors(null_interceptor): post.assert_called_once() -def test_mark_insight_accepted_rest_bad_request( - transport: str = "rest", request_type=recommender_service.MarkInsightAcceptedRequest +def test_get_recommendation_rest_bad_request( + transport: str = "rest", request_type=recommender_service.GetRecommendationRequest ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5157,7 +6383,7 @@ def test_mark_insight_accepted_rest_bad_request( # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" } request = request_type(**request_init) @@ -5170,10 +6396,10 @@ def test_mark_insight_accepted_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.mark_insight_accepted(request) + client.get_recommendation(request) -def test_mark_insight_accepted_rest_flattened(): +def test_get_recommendation_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -5182,43 +6408,41 @@ def test_mark_insight_accepted_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 = insight.Insight() + return_value = recommendation.Recommendation() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/insights/sample4" + "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" } # get truthy value for each flattened field mock_args = dict( name="name_value", - state_metadata={"key_value": "value_value"}, - etag="etag_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = insight.Insight.pb(return_value) + pb_return_value = recommendation.Recommendation.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.mark_insight_accepted(**mock_args) + client.get_recommendation(**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/v1beta1/{name=projects/*/locations/*/insightTypes/*/insights/*}:markAccepted" + "%s/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}" % client.transport._host, args[1], ) -def test_mark_insight_accepted_rest_flattened_error(transport: str = "rest"): +def test_get_recommendation_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -5227,15 +6451,13 @@ def test_mark_insight_accepted_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.mark_insight_accepted( - recommender_service.MarkInsightAcceptedRequest(), + client.get_recommendation( + recommender_service.GetRecommendationRequest(), name="name_value", - state_metadata={"key_value": "value_value"}, - etag="etag_value", ) -def test_mark_insight_accepted_rest_error(): +def test_get_recommendation_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -5244,51 +6466,62 @@ def test_mark_insight_accepted_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.ListRecommendationsRequest, + recommender_service.MarkRecommendationClaimedRequest, dict, ], ) -def test_list_recommendations_rest(request_type): +def test_mark_recommendation_claimed_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/recommenders/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + } 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 = recommender_service.ListRecommendationsResponse( - next_page_token="next_page_token_value", + return_value = recommendation.Recommendation( + name="name_value", + description="description_value", + recommender_subtype="recommender_subtype_value", + priority=recommendation.Recommendation.Priority.P4, + etag="etag_value", + xor_group_id="xor_group_id_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_service.ListRecommendationsResponse.pb( - return_value - ) + pb_return_value = recommendation.Recommendation.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.list_recommendations(request) + response = client.mark_recommendation_claimed(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListRecommendationsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, recommendation.Recommendation) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.recommender_subtype == "recommender_subtype_value" + assert response.priority == recommendation.Recommendation.Priority.P4 + assert response.etag == "etag_value" + assert response.xor_group_id == "xor_group_id_value" -def test_list_recommendations_rest_required_fields( - request_type=recommender_service.ListRecommendationsRequest, +def test_mark_recommendation_claimed_rest_required_fields( + request_type=recommender_service.MarkRecommendationClaimedRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" + request_init["etag"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -5303,29 +6536,24 @@ def test_list_recommendations_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_recommendations._get_unset_required_fields(jsonified_request) + ).mark_recommendation_claimed._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" + jsonified_request["etag"] = "etag_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_recommendations._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", - ) - ) + ).mark_recommendation_claimed._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" + assert "etag" in jsonified_request + assert jsonified_request["etag"] == "etag_value" client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5334,7 +6562,7 @@ def test_list_recommendations_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = recommender_service.ListRecommendationsResponse() + return_value = recommendation.Recommendation() # 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 @@ -5346,49 +6574,47 @@ def test_list_recommendations_rest_required_fields( 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() response_value.status_code = 200 - pb_return_value = recommender_service.ListRecommendationsResponse.pb( - return_value - ) + pb_return_value = recommendation.Recommendation.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.list_recommendations(request) + response = client.mark_recommendation_claimed(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_recommendations_rest_unset_required_fields(): +def test_mark_recommendation_claimed_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_recommendations._get_unset_required_fields({}) + unset_fields = transport.mark_recommendation_claimed._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "filter", - "pageSize", - "pageToken", + "name", + "etag", ) ) - & set(("parent",)) ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_recommendations_rest_interceptors(null_interceptor): +def test_mark_recommendation_claimed_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -5401,14 +6627,14 @@ def test_list_recommendations_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_list_recommendations" + transports.RecommenderRestInterceptor, "post_mark_recommendation_claimed" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_list_recommendations" + transports.RecommenderRestInterceptor, "pre_mark_recommendation_claimed" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.ListRecommendationsRequest.pb( - recommender_service.ListRecommendationsRequest() + pb_message = recommender_service.MarkRecommendationClaimedRequest.pb( + recommender_service.MarkRecommendationClaimedRequest() ) transcode.return_value = { "method": "post", @@ -5420,21 +6646,19 @@ def test_list_recommendations_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = ( - recommender_service.ListRecommendationsResponse.to_json( - recommender_service.ListRecommendationsResponse() - ) + req.return_value._content = recommendation.Recommendation.to_json( + recommendation.Recommendation() ) - request = recommender_service.ListRecommendationsRequest() + request = recommender_service.MarkRecommendationClaimedRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = recommender_service.ListRecommendationsResponse() + post.return_value = recommendation.Recommendation() - client.list_recommendations( + client.mark_recommendation_claimed( request, metadata=[ ("key", "val"), @@ -5446,8 +6670,9 @@ def test_list_recommendations_rest_interceptors(null_interceptor): post.assert_called_once() -def test_list_recommendations_rest_bad_request( - transport: str = "rest", request_type=recommender_service.ListRecommendationsRequest +def test_mark_recommendation_claimed_rest_bad_request( + transport: str = "rest", + request_type=recommender_service.MarkRecommendationClaimedRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5455,7 +6680,9 @@ def test_list_recommendations_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/recommenders/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -5467,10 +6694,10 @@ def test_list_recommendations_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.list_recommendations(request) + client.mark_recommendation_claimed(request) -def test_list_recommendations_rest_flattened(): +def test_mark_recommendation_claimed_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -5479,44 +6706,43 @@ def test_list_recommendations_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 = recommender_service.ListRecommendationsResponse() + return_value = recommendation.Recommendation() # get arguments that satisfy an http rule for this method sample_request = { - "parent": "projects/sample1/locations/sample2/recommenders/sample3" + "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - filter="filter_value", + name="name_value", + state_metadata={"key_value": "value_value"}, + etag="etag_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_service.ListRecommendationsResponse.pb( - return_value - ) + pb_return_value = recommendation.Recommendation.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.list_recommendations(**mock_args) + client.mark_recommendation_claimed(**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/v1beta1/{parent=projects/*/locations/*/recommenders/*}/recommendations" + "%s/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed" % client.transport._host, args[1], ) -def test_list_recommendations_rest_flattened_error(transport: str = "rest"): +def test_mark_recommendation_claimed_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -5525,86 +6751,28 @@ def test_list_recommendations_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_recommendations( - recommender_service.ListRecommendationsRequest(), - parent="parent_value", - filter="filter_value", + client.mark_recommendation_claimed( + recommender_service.MarkRecommendationClaimedRequest(), + name="name_value", + state_metadata={"key_value": "value_value"}, + etag="etag_value", ) -def test_list_recommendations_rest_pager(transport: str = "rest"): +def test_mark_recommendation_claimed_rest_error(): client = RecommenderClient( - 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 = ( - recommender_service.ListRecommendationsResponse( - recommendations=[ - recommendation.Recommendation(), - recommendation.Recommendation(), - recommendation.Recommendation(), - ], - next_page_token="abc", - ), - recommender_service.ListRecommendationsResponse( - recommendations=[], - next_page_token="def", - ), - recommender_service.ListRecommendationsResponse( - recommendations=[ - recommendation.Recommendation(), - ], - next_page_token="ghi", - ), - recommender_service.ListRecommendationsResponse( - recommendations=[ - recommendation.Recommendation(), - recommendation.Recommendation(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - recommender_service.ListRecommendationsResponse.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": "projects/sample1/locations/sample2/recommenders/sample3" - } - - pager = client.list_recommendations(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, recommendation.Recommendation) for i in results) - - pages = list(client.list_recommendations(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", [ - recommender_service.GetRecommendationRequest, + recommender_service.MarkRecommendationSucceededRequest, dict, ], ) -def test_get_recommendation_rest(request_type): +def test_mark_recommendation_succeeded_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -5636,7 +6804,7 @@ def test_get_recommendation_rest(request_type): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_recommendation(request) + response = client.mark_recommendation_succeeded(request) # Establish that the response is the type that we expect. assert isinstance(response, recommendation.Recommendation) @@ -5648,13 +6816,14 @@ def test_get_recommendation_rest(request_type): assert response.xor_group_id == "xor_group_id_value" -def test_get_recommendation_rest_required_fields( - request_type=recommender_service.GetRecommendationRequest, +def test_mark_recommendation_succeeded_rest_required_fields( + request_type=recommender_service.MarkRecommendationSucceededRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} request_init["name"] = "" + request_init["etag"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -5669,21 +6838,24 @@ def test_get_recommendation_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_recommendation._get_unset_required_fields(jsonified_request) + ).mark_recommendation_succeeded._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["etag"] = "etag_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_recommendation._get_unset_required_fields(jsonified_request) + ).mark_recommendation_succeeded._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 "etag" in jsonified_request + assert jsonified_request["etag"] == "etag_value" client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5704,9 +6876,10 @@ def test_get_recommendation_rest_required_fields( 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() @@ -5718,24 +6891,34 @@ def test_get_recommendation_rest_required_fields( response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_recommendation(request) + response = client.mark_recommendation_succeeded(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_recommendation_rest_unset_required_fields(): +def test_mark_recommendation_succeeded_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_recommendation._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.mark_recommendation_succeeded._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set(()) + & set( + ( + "name", + "etag", + ) + ) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_recommendation_rest_interceptors(null_interceptor): +def test_mark_recommendation_succeeded_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -5748,14 +6931,14 @@ def test_get_recommendation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_get_recommendation" + transports.RecommenderRestInterceptor, "post_mark_recommendation_succeeded" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_get_recommendation" + transports.RecommenderRestInterceptor, "pre_mark_recommendation_succeeded" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.GetRecommendationRequest.pb( - recommender_service.GetRecommendationRequest() + pb_message = recommender_service.MarkRecommendationSucceededRequest.pb( + recommender_service.MarkRecommendationSucceededRequest() ) transcode.return_value = { "method": "post", @@ -5771,7 +6954,7 @@ def test_get_recommendation_rest_interceptors(null_interceptor): recommendation.Recommendation() ) - request = recommender_service.GetRecommendationRequest() + request = recommender_service.MarkRecommendationSucceededRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -5779,7 +6962,7 @@ def test_get_recommendation_rest_interceptors(null_interceptor): pre.return_value = request, metadata post.return_value = recommendation.Recommendation() - client.get_recommendation( + client.mark_recommendation_succeeded( request, metadata=[ ("key", "val"), @@ -5791,8 +6974,9 @@ def test_get_recommendation_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_recommendation_rest_bad_request( - transport: str = "rest", request_type=recommender_service.GetRecommendationRequest +def test_mark_recommendation_succeeded_rest_bad_request( + transport: str = "rest", + request_type=recommender_service.MarkRecommendationSucceededRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -5814,10 +6998,10 @@ def test_get_recommendation_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_recommendation(request) + client.mark_recommendation_succeeded(request) -def test_get_recommendation_rest_flattened(): +def test_mark_recommendation_succeeded_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -5836,6 +7020,8 @@ def test_get_recommendation_rest_flattened(): # get truthy value for each flattened field mock_args = dict( name="name_value", + state_metadata={"key_value": "value_value"}, + etag="etag_value", ) mock_args.update(sample_request) @@ -5847,20 +7033,20 @@ def test_get_recommendation_rest_flattened(): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_recommendation(**mock_args) + client.mark_recommendation_succeeded(**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/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}" + "%s/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded" % client.transport._host, args[1], ) -def test_get_recommendation_rest_flattened_error(transport: str = "rest"): +def test_mark_recommendation_succeeded_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -5869,13 +7055,15 @@ def test_get_recommendation_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_recommendation( - recommender_service.GetRecommendationRequest(), + client.mark_recommendation_succeeded( + recommender_service.MarkRecommendationSucceededRequest(), name="name_value", + state_metadata={"key_value": "value_value"}, + etag="etag_value", ) -def test_get_recommendation_rest_error(): +def test_mark_recommendation_succeeded_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -5884,11 +7072,11 @@ def test_get_recommendation_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.MarkRecommendationClaimedRequest, + recommender_service.MarkRecommendationFailedRequest, dict, ], ) -def test_mark_recommendation_claimed_rest(request_type): +def test_mark_recommendation_failed_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -5920,7 +7108,7 @@ def test_mark_recommendation_claimed_rest(request_type): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_recommendation_claimed(request) + response = client.mark_recommendation_failed(request) # Establish that the response is the type that we expect. assert isinstance(response, recommendation.Recommendation) @@ -5932,8 +7120,8 @@ def test_mark_recommendation_claimed_rest(request_type): assert response.xor_group_id == "xor_group_id_value" -def test_mark_recommendation_claimed_rest_required_fields( - request_type=recommender_service.MarkRecommendationClaimedRequest, +def test_mark_recommendation_failed_rest_required_fields( + request_type=recommender_service.MarkRecommendationFailedRequest, ): transport_class = transports.RecommenderRestTransport @@ -5954,7 +7142,7 @@ def test_mark_recommendation_claimed_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_recommendation_claimed._get_unset_required_fields(jsonified_request) + ).mark_recommendation_failed._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -5964,7 +7152,7 @@ def test_mark_recommendation_claimed_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_recommendation_claimed._get_unset_required_fields(jsonified_request) + ).mark_recommendation_failed._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -6007,19 +7195,19 @@ def test_mark_recommendation_claimed_rest_required_fields( response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_recommendation_claimed(request) + response = client.mark_recommendation_failed(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_mark_recommendation_claimed_rest_unset_required_fields(): +def test_mark_recommendation_failed_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.mark_recommendation_claimed._get_unset_required_fields({}) + unset_fields = transport.mark_recommendation_failed._get_unset_required_fields({}) assert set(unset_fields) == ( set(()) & set( @@ -6032,7 +7220,7 @@ def test_mark_recommendation_claimed_rest_unset_required_fields(): @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_mark_recommendation_claimed_rest_interceptors(null_interceptor): +def test_mark_recommendation_failed_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -6045,14 +7233,14 @@ def test_mark_recommendation_claimed_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_mark_recommendation_claimed" + transports.RecommenderRestInterceptor, "post_mark_recommendation_failed" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_mark_recommendation_claimed" + transports.RecommenderRestInterceptor, "pre_mark_recommendation_failed" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.MarkRecommendationClaimedRequest.pb( - recommender_service.MarkRecommendationClaimedRequest() + pb_message = recommender_service.MarkRecommendationFailedRequest.pb( + recommender_service.MarkRecommendationFailedRequest() ) transcode.return_value = { "method": "post", @@ -6068,7 +7256,7 @@ def test_mark_recommendation_claimed_rest_interceptors(null_interceptor): recommendation.Recommendation() ) - request = recommender_service.MarkRecommendationClaimedRequest() + request = recommender_service.MarkRecommendationFailedRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -6076,7 +7264,7 @@ def test_mark_recommendation_claimed_rest_interceptors(null_interceptor): pre.return_value = request, metadata post.return_value = recommendation.Recommendation() - client.mark_recommendation_claimed( + client.mark_recommendation_failed( request, metadata=[ ("key", "val"), @@ -6088,9 +7276,9 @@ def test_mark_recommendation_claimed_rest_interceptors(null_interceptor): post.assert_called_once() -def test_mark_recommendation_claimed_rest_bad_request( +def test_mark_recommendation_failed_rest_bad_request( transport: str = "rest", - request_type=recommender_service.MarkRecommendationClaimedRequest, + request_type=recommender_service.MarkRecommendationFailedRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6112,10 +7300,10 @@ def test_mark_recommendation_claimed_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.mark_recommendation_claimed(request) + client.mark_recommendation_failed(request) -def test_mark_recommendation_claimed_rest_flattened(): +def test_mark_recommendation_failed_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -6147,20 +7335,20 @@ def test_mark_recommendation_claimed_rest_flattened(): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.mark_recommendation_claimed(**mock_args) + client.mark_recommendation_failed(**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/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed" + "%s/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed" % client.transport._host, args[1], ) -def test_mark_recommendation_claimed_rest_flattened_error(transport: str = "rest"): +def test_mark_recommendation_failed_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -6169,15 +7357,15 @@ def test_mark_recommendation_claimed_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.mark_recommendation_claimed( - recommender_service.MarkRecommendationClaimedRequest(), + client.mark_recommendation_failed( + recommender_service.MarkRecommendationFailedRequest(), name="name_value", state_metadata={"key_value": "value_value"}, etag="etag_value", ) -def test_mark_recommendation_claimed_rest_error(): +def test_mark_recommendation_failed_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -6186,11 +7374,11 @@ def test_mark_recommendation_claimed_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.MarkRecommendationSucceededRequest, + recommender_service.GetRecommenderConfigRequest, dict, ], ) -def test_mark_recommendation_succeeded_rest(request_type): +def test_get_recommender_config_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -6198,50 +7386,45 @@ def test_mark_recommendation_succeeded_rest(request_type): # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + "name": "projects/sample1/locations/sample2/recommenders/sample3/config" } 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 = recommendation.Recommendation( + return_value = recommender_config.RecommenderConfig( name="name_value", - description="description_value", - recommender_subtype="recommender_subtype_value", - priority=recommendation.Recommendation.Priority.P4, etag="etag_value", - xor_group_id="xor_group_id_value", + revision_id="revision_id_value", + display_name="display_name_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommendation.Recommendation.pb(return_value) + pb_return_value = recommender_config.RecommenderConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_recommendation_succeeded(request) + response = client.get_recommender_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, recommendation.Recommendation) + assert isinstance(response, recommender_config.RecommenderConfig) assert response.name == "name_value" - assert response.description == "description_value" - assert response.recommender_subtype == "recommender_subtype_value" - assert response.priority == recommendation.Recommendation.Priority.P4 assert response.etag == "etag_value" - assert response.xor_group_id == "xor_group_id_value" + assert response.revision_id == "revision_id_value" + assert response.display_name == "display_name_value" -def test_mark_recommendation_succeeded_rest_required_fields( - request_type=recommender_service.MarkRecommendationSucceededRequest, +def test_get_recommender_config_rest_required_fields( + request_type=recommender_service.GetRecommenderConfigRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} request_init["name"] = "" - request_init["etag"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -6256,24 +7439,21 @@ def test_mark_recommendation_succeeded_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_recommendation_succeeded._get_unset_required_fields(jsonified_request) + ).get_recommender_config._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["etag"] = "etag_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_recommendation_succeeded._get_unset_required_fields(jsonified_request) + ).get_recommender_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone assert "name" in jsonified_request assert jsonified_request["name"] == "name_value" - assert "etag" in jsonified_request - assert jsonified_request["etag"] == "etag_value" client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6282,7 +7462,7 @@ def test_mark_recommendation_succeeded_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = recommendation.Recommendation() + return_value = recommender_config.RecommenderConfig() # 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 @@ -6294,49 +7474,38 @@ def test_mark_recommendation_succeeded_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - pb_return_value = recommendation.Recommendation.pb(return_value) + pb_return_value = recommender_config.RecommenderConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_recommendation_succeeded(request) + response = client.get_recommender_config(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_mark_recommendation_succeeded_rest_unset_required_fields(): +def test_get_recommender_config_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.mark_recommendation_succeeded._get_unset_required_fields( - {} - ) - assert set(unset_fields) == ( - set(()) - & set( - ( - "name", - "etag", - ) - ) - ) + unset_fields = transport.get_recommender_config._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_mark_recommendation_succeeded_rest_interceptors(null_interceptor): +def test_get_recommender_config_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -6349,14 +7518,14 @@ def test_mark_recommendation_succeeded_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_mark_recommendation_succeeded" + transports.RecommenderRestInterceptor, "post_get_recommender_config" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_mark_recommendation_succeeded" + transports.RecommenderRestInterceptor, "pre_get_recommender_config" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.MarkRecommendationSucceededRequest.pb( - recommender_service.MarkRecommendationSucceededRequest() + pb_message = recommender_service.GetRecommenderConfigRequest.pb( + recommender_service.GetRecommenderConfigRequest() ) transcode.return_value = { "method": "post", @@ -6368,19 +7537,19 @@ def test_mark_recommendation_succeeded_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = recommendation.Recommendation.to_json( - recommendation.Recommendation() + req.return_value._content = recommender_config.RecommenderConfig.to_json( + recommender_config.RecommenderConfig() ) - request = recommender_service.MarkRecommendationSucceededRequest() + request = recommender_service.GetRecommenderConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = recommendation.Recommendation() + post.return_value = recommender_config.RecommenderConfig() - client.mark_recommendation_succeeded( + client.get_recommender_config( request, metadata=[ ("key", "val"), @@ -6392,9 +7561,9 @@ def test_mark_recommendation_succeeded_rest_interceptors(null_interceptor): post.assert_called_once() -def test_mark_recommendation_succeeded_rest_bad_request( +def test_get_recommender_config_rest_bad_request( transport: str = "rest", - request_type=recommender_service.MarkRecommendationSucceededRequest, + request_type=recommender_service.GetRecommenderConfigRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6403,7 +7572,7 @@ def test_mark_recommendation_succeeded_rest_bad_request( # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + "name": "projects/sample1/locations/sample2/recommenders/sample3/config" } request = request_type(**request_init) @@ -6416,10 +7585,10 @@ def test_mark_recommendation_succeeded_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.mark_recommendation_succeeded(request) + client.get_recommender_config(request) -def test_mark_recommendation_succeeded_rest_flattened(): +def test_get_recommender_config_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -6428,43 +7597,41 @@ def test_mark_recommendation_succeeded_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 = recommendation.Recommendation() + return_value = recommender_config.RecommenderConfig() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + "name": "projects/sample1/locations/sample2/recommenders/sample3/config" } # get truthy value for each flattened field mock_args = dict( name="name_value", - state_metadata={"key_value": "value_value"}, - etag="etag_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommendation.Recommendation.pb(return_value) + pb_return_value = recommender_config.RecommenderConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.mark_recommendation_succeeded(**mock_args) + client.get_recommender_config(**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/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded" + "%s/v1beta1/{name=projects/*/locations/*/recommenders/*/config}" % client.transport._host, args[1], ) -def test_mark_recommendation_succeeded_rest_flattened_error(transport: str = "rest"): +def test_get_recommender_config_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -6473,15 +7640,13 @@ def test_mark_recommendation_succeeded_rest_flattened_error(transport: str = "re # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.mark_recommendation_succeeded( - recommender_service.MarkRecommendationSucceededRequest(), + client.get_recommender_config( + recommender_service.GetRecommenderConfigRequest(), name="name_value", - state_metadata={"key_value": "value_value"}, - etag="etag_value", ) -def test_mark_recommendation_succeeded_rest_error(): +def test_get_recommender_config_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -6490,11 +7655,11 @@ def test_mark_recommendation_succeeded_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.MarkRecommendationFailedRequest, + recommender_service.UpdateRecommenderConfigRequest, dict, ], ) -def test_mark_recommendation_failed_rest(request_type): +def test_update_recommender_config_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -6502,50 +7667,55 @@ def test_mark_recommendation_failed_rest(request_type): # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + "recommender_config": { + "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + } + } + request_init["recommender_config"] = { + "name": "projects/sample1/locations/sample2/recommenders/sample3/config", + "recommender_generation_config": {"params": {"fields": {}}}, + "etag": "etag_value", + "update_time": {"seconds": 751, "nanos": 543}, + "revision_id": "revision_id_value", + "annotations": {}, + "display_name": "display_name_value", } 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 = recommendation.Recommendation( + return_value = gcr_recommender_config.RecommenderConfig( name="name_value", - description="description_value", - recommender_subtype="recommender_subtype_value", - priority=recommendation.Recommendation.Priority.P4, etag="etag_value", - xor_group_id="xor_group_id_value", + revision_id="revision_id_value", + display_name="display_name_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommendation.Recommendation.pb(return_value) + pb_return_value = gcr_recommender_config.RecommenderConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_recommendation_failed(request) + response = client.update_recommender_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, recommendation.Recommendation) + assert isinstance(response, gcr_recommender_config.RecommenderConfig) assert response.name == "name_value" - assert response.description == "description_value" - assert response.recommender_subtype == "recommender_subtype_value" - assert response.priority == recommendation.Recommendation.Priority.P4 assert response.etag == "etag_value" - assert response.xor_group_id == "xor_group_id_value" + assert response.revision_id == "revision_id_value" + assert response.display_name == "display_name_value" -def test_mark_recommendation_failed_rest_required_fields( - request_type=recommender_service.MarkRecommendationFailedRequest, +def test_update_recommender_config_rest_required_fields( + request_type=recommender_service.UpdateRecommenderConfigRequest, ): transport_class = transports.RecommenderRestTransport request_init = {} - request_init["name"] = "" - request_init["etag"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -6560,24 +7730,24 @@ def test_mark_recommendation_failed_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_recommendation_failed._get_unset_required_fields(jsonified_request) + ).update_recommender_config._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["etag"] = "etag_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).mark_recommendation_failed._get_unset_required_fields(jsonified_request) + ).update_recommender_config._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "update_mask", + "validate_only", + ) + ) 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 "etag" in jsonified_request - assert jsonified_request["etag"] == "etag_value" client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6586,7 +7756,7 @@ def test_mark_recommendation_failed_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = recommendation.Recommendation() + return_value = gcr_recommender_config.RecommenderConfig() # 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 @@ -6598,7 +7768,7 @@ def test_mark_recommendation_failed_rest_required_fields( 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 @@ -6607,38 +7777,38 @@ def test_mark_recommendation_failed_rest_required_fields( response_value = Response() response_value.status_code = 200 - pb_return_value = recommendation.Recommendation.pb(return_value) + pb_return_value = gcr_recommender_config.RecommenderConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.mark_recommendation_failed(request) + response = client.update_recommender_config(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_mark_recommendation_failed_rest_unset_required_fields(): +def test_update_recommender_config_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.mark_recommendation_failed._get_unset_required_fields({}) + unset_fields = transport.update_recommender_config._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) - & set( + set( ( - "name", - "etag", + "updateMask", + "validateOnly", ) ) + & set(("recommenderConfig",)) ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_mark_recommendation_failed_rest_interceptors(null_interceptor): +def test_update_recommender_config_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -6651,14 +7821,14 @@ def test_mark_recommendation_failed_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_mark_recommendation_failed" + transports.RecommenderRestInterceptor, "post_update_recommender_config" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_mark_recommendation_failed" + transports.RecommenderRestInterceptor, "pre_update_recommender_config" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.MarkRecommendationFailedRequest.pb( - recommender_service.MarkRecommendationFailedRequest() + pb_message = recommender_service.UpdateRecommenderConfigRequest.pb( + recommender_service.UpdateRecommenderConfigRequest() ) transcode.return_value = { "method": "post", @@ -6670,19 +7840,19 @@ def test_mark_recommendation_failed_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = recommendation.Recommendation.to_json( - recommendation.Recommendation() + req.return_value._content = gcr_recommender_config.RecommenderConfig.to_json( + gcr_recommender_config.RecommenderConfig() ) - request = recommender_service.MarkRecommendationFailedRequest() + request = recommender_service.UpdateRecommenderConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = recommendation.Recommendation() + post.return_value = gcr_recommender_config.RecommenderConfig() - client.mark_recommendation_failed( + client.update_recommender_config( request, metadata=[ ("key", "val"), @@ -6694,9 +7864,9 @@ def test_mark_recommendation_failed_rest_interceptors(null_interceptor): post.assert_called_once() -def test_mark_recommendation_failed_rest_bad_request( +def test_update_recommender_config_rest_bad_request( transport: str = "rest", - request_type=recommender_service.MarkRecommendationFailedRequest, + request_type=recommender_service.UpdateRecommenderConfigRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6705,7 +7875,18 @@ def test_mark_recommendation_failed_rest_bad_request( # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + "recommender_config": { + "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + } + } + request_init["recommender_config"] = { + "name": "projects/sample1/locations/sample2/recommenders/sample3/config", + "recommender_generation_config": {"params": {"fields": {}}}, + "etag": "etag_value", + "update_time": {"seconds": 751, "nanos": 543}, + "revision_id": "revision_id_value", + "annotations": {}, + "display_name": "display_name_value", } request = request_type(**request_init) @@ -6718,10 +7899,10 @@ def test_mark_recommendation_failed_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.mark_recommendation_failed(request) + client.update_recommender_config(request) -def test_mark_recommendation_failed_rest_flattened(): +def test_update_recommender_config_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -6730,43 +7911,46 @@ def test_mark_recommendation_failed_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 = recommendation.Recommendation() + return_value = gcr_recommender_config.RecommenderConfig() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/recommendations/sample4" + "recommender_config": { + "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + } } # get truthy value for each flattened field mock_args = dict( - name="name_value", - state_metadata={"key_value": "value_value"}, - etag="etag_value", + recommender_config=gcr_recommender_config.RecommenderConfig( + 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 - pb_return_value = recommendation.Recommendation.pb(return_value) + pb_return_value = gcr_recommender_config.RecommenderConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.mark_recommendation_failed(**mock_args) + client.update_recommender_config(**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/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed" + "%s/v1beta1/{recommender_config.name=projects/*/locations/*/recommenders/*/config}" % client.transport._host, args[1], ) -def test_mark_recommendation_failed_rest_flattened_error(transport: str = "rest"): +def test_update_recommender_config_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -6775,15 +7959,16 @@ def test_mark_recommendation_failed_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.mark_recommendation_failed( - recommender_service.MarkRecommendationFailedRequest(), - name="name_value", - state_metadata={"key_value": "value_value"}, - etag="etag_value", + client.update_recommender_config( + recommender_service.UpdateRecommenderConfigRequest(), + recommender_config=gcr_recommender_config.RecommenderConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_mark_recommendation_failed_rest_error(): +def test_update_recommender_config_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -6792,11 +7977,11 @@ def test_mark_recommendation_failed_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.GetRecommenderConfigRequest, + recommender_service.GetInsightTypeConfigRequest, dict, ], ) -def test_get_recommender_config_rest(request_type): +def test_get_insight_type_config_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -6804,14 +7989,14 @@ def test_get_recommender_config_rest(request_type): # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" } 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 = recommender_config.RecommenderConfig( + return_value = insight_type_config.InsightTypeConfig( name="name_value", etag="etag_value", revision_id="revision_id_value", @@ -6821,23 +8006,23 @@ def test_get_recommender_config_rest(request_type): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_config.RecommenderConfig.pb(return_value) + pb_return_value = insight_type_config.InsightTypeConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_recommender_config(request) + response = client.get_insight_type_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, recommender_config.RecommenderConfig) + assert isinstance(response, insight_type_config.InsightTypeConfig) assert response.name == "name_value" assert response.etag == "etag_value" assert response.revision_id == "revision_id_value" assert response.display_name == "display_name_value" -def test_get_recommender_config_rest_required_fields( - request_type=recommender_service.GetRecommenderConfigRequest, +def test_get_insight_type_config_rest_required_fields( + request_type=recommender_service.GetInsightTypeConfigRequest, ): transport_class = transports.RecommenderRestTransport @@ -6857,7 +8042,7 @@ def test_get_recommender_config_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_recommender_config._get_unset_required_fields(jsonified_request) + ).get_insight_type_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -6866,7 +8051,7 @@ def test_get_recommender_config_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_recommender_config._get_unset_required_fields(jsonified_request) + ).get_insight_type_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -6880,7 +8065,7 @@ def test_get_recommender_config_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = recommender_config.RecommenderConfig() + return_value = insight_type_config.InsightTypeConfig() # 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 @@ -6900,30 +8085,30 @@ def test_get_recommender_config_rest_required_fields( response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_config.RecommenderConfig.pb(return_value) + pb_return_value = insight_type_config.InsightTypeConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_recommender_config(request) + response = client.get_insight_type_config(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_recommender_config_rest_unset_required_fields(): +def test_get_insight_type_config_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_recommender_config._get_unset_required_fields({}) + unset_fields = transport.get_insight_type_config._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_recommender_config_rest_interceptors(null_interceptor): +def test_get_insight_type_config_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -6936,14 +8121,14 @@ def test_get_recommender_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_get_recommender_config" + transports.RecommenderRestInterceptor, "post_get_insight_type_config" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_get_recommender_config" + transports.RecommenderRestInterceptor, "pre_get_insight_type_config" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.GetRecommenderConfigRequest.pb( - recommender_service.GetRecommenderConfigRequest() + pb_message = recommender_service.GetInsightTypeConfigRequest.pb( + recommender_service.GetInsightTypeConfigRequest() ) transcode.return_value = { "method": "post", @@ -6955,19 +8140,19 @@ def test_get_recommender_config_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = recommender_config.RecommenderConfig.to_json( - recommender_config.RecommenderConfig() + req.return_value._content = insight_type_config.InsightTypeConfig.to_json( + insight_type_config.InsightTypeConfig() ) - request = recommender_service.GetRecommenderConfigRequest() + request = recommender_service.GetInsightTypeConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = recommender_config.RecommenderConfig() + post.return_value = insight_type_config.InsightTypeConfig() - client.get_recommender_config( + client.get_insight_type_config( request, metadata=[ ("key", "val"), @@ -6979,9 +8164,9 @@ def test_get_recommender_config_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_recommender_config_rest_bad_request( +def test_get_insight_type_config_rest_bad_request( transport: str = "rest", - request_type=recommender_service.GetRecommenderConfigRequest, + request_type=recommender_service.GetInsightTypeConfigRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6990,7 +8175,7 @@ def test_get_recommender_config_rest_bad_request( # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" } request = request_type(**request_init) @@ -7003,10 +8188,10 @@ def test_get_recommender_config_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_recommender_config(request) + client.get_insight_type_config(request) -def test_get_recommender_config_rest_flattened(): +def test_get_insight_type_config_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -7015,11 +8200,11 @@ def test_get_recommender_config_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 = recommender_config.RecommenderConfig() + return_value = insight_type_config.InsightTypeConfig() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" } # get truthy value for each flattened field @@ -7031,25 +8216,25 @@ def test_get_recommender_config_rest_flattened(): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = recommender_config.RecommenderConfig.pb(return_value) + pb_return_value = insight_type_config.InsightTypeConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_recommender_config(**mock_args) + client.get_insight_type_config(**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/v1beta1/{name=projects/*/locations/*/recommenders/*/config}" + "%s/v1beta1/{name=projects/*/locations/*/insightTypes/*/config}" % client.transport._host, args[1], ) -def test_get_recommender_config_rest_flattened_error(transport: str = "rest"): +def test_get_insight_type_config_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -7058,13 +8243,13 @@ def test_get_recommender_config_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_recommender_config( - recommender_service.GetRecommenderConfigRequest(), + client.get_insight_type_config( + recommender_service.GetInsightTypeConfigRequest(), name="name_value", ) -def test_get_recommender_config_rest_error(): +def test_get_insight_type_config_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -7073,11 +8258,11 @@ def test_get_recommender_config_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.UpdateRecommenderConfigRequest, + recommender_service.UpdateInsightTypeConfigRequest, dict, ], ) -def test_update_recommender_config_rest(request_type): +def test_update_insight_type_config_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -7085,13 +8270,13 @@ def test_update_recommender_config_rest(request_type): # send a request that will satisfy transcoding request_init = { - "recommender_config": { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + "insight_type_config": { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" } } - request_init["recommender_config"] = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config", - "recommender_generation_config": {"params": {"fields": {}}}, + request_init["insight_type_config"] = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config", + "insight_type_generation_config": {"params": {"fields": {}}}, "etag": "etag_value", "update_time": {"seconds": 751, "nanos": 543}, "revision_id": "revision_id_value", @@ -7103,7 +8288,7 @@ def test_update_recommender_config_rest(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 = gcr_recommender_config.RecommenderConfig( + return_value = gcr_insight_type_config.InsightTypeConfig( name="name_value", etag="etag_value", revision_id="revision_id_value", @@ -7113,23 +8298,23 @@ def test_update_recommender_config_rest(request_type): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = gcr_recommender_config.RecommenderConfig.pb(return_value) + pb_return_value = gcr_insight_type_config.InsightTypeConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_recommender_config(request) + response = client.update_insight_type_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, gcr_recommender_config.RecommenderConfig) + assert isinstance(response, gcr_insight_type_config.InsightTypeConfig) assert response.name == "name_value" assert response.etag == "etag_value" assert response.revision_id == "revision_id_value" assert response.display_name == "display_name_value" -def test_update_recommender_config_rest_required_fields( - request_type=recommender_service.UpdateRecommenderConfigRequest, +def test_update_insight_type_config_rest_required_fields( + request_type=recommender_service.UpdateInsightTypeConfigRequest, ): transport_class = transports.RecommenderRestTransport @@ -7148,14 +8333,14 @@ def test_update_recommender_config_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_recommender_config._get_unset_required_fields(jsonified_request) + ).update_insight_type_config._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_recommender_config._get_unset_required_fields(jsonified_request) + ).update_insight_type_config._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( @@ -7174,7 +8359,7 @@ def test_update_recommender_config_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gcr_recommender_config.RecommenderConfig() + return_value = gcr_insight_type_config.InsightTypeConfig() # 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 @@ -7195,25 +8380,25 @@ def test_update_recommender_config_rest_required_fields( response_value = Response() response_value.status_code = 200 - pb_return_value = gcr_recommender_config.RecommenderConfig.pb(return_value) + pb_return_value = gcr_insight_type_config.InsightTypeConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_recommender_config(request) + response = client.update_insight_type_config(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_recommender_config_rest_unset_required_fields(): +def test_update_insight_type_config_rest_unset_required_fields(): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_recommender_config._get_unset_required_fields({}) + unset_fields = transport.update_insight_type_config._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( @@ -7221,12 +8406,12 @@ def test_update_recommender_config_rest_unset_required_fields(): "validateOnly", ) ) - & set(("recommenderConfig",)) + & set(("insightTypeConfig",)) ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_recommender_config_rest_interceptors(null_interceptor): +def test_update_insight_type_config_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -7239,14 +8424,14 @@ def test_update_recommender_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_update_recommender_config" + transports.RecommenderRestInterceptor, "post_update_insight_type_config" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_update_recommender_config" + transports.RecommenderRestInterceptor, "pre_update_insight_type_config" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.UpdateRecommenderConfigRequest.pb( - recommender_service.UpdateRecommenderConfigRequest() + pb_message = recommender_service.UpdateInsightTypeConfigRequest.pb( + recommender_service.UpdateInsightTypeConfigRequest() ) transcode.return_value = { "method": "post", @@ -7258,19 +8443,19 @@ def test_update_recommender_config_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gcr_recommender_config.RecommenderConfig.to_json( - gcr_recommender_config.RecommenderConfig() + req.return_value._content = gcr_insight_type_config.InsightTypeConfig.to_json( + gcr_insight_type_config.InsightTypeConfig() ) - request = recommender_service.UpdateRecommenderConfigRequest() + request = recommender_service.UpdateInsightTypeConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gcr_recommender_config.RecommenderConfig() + post.return_value = gcr_insight_type_config.InsightTypeConfig() - client.update_recommender_config( + client.update_insight_type_config( request, metadata=[ ("key", "val"), @@ -7282,9 +8467,9 @@ def test_update_recommender_config_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_recommender_config_rest_bad_request( +def test_update_insight_type_config_rest_bad_request( transport: str = "rest", - request_type=recommender_service.UpdateRecommenderConfigRequest, + request_type=recommender_service.UpdateInsightTypeConfigRequest, ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -7293,13 +8478,13 @@ def test_update_recommender_config_rest_bad_request( # send a request that will satisfy transcoding request_init = { - "recommender_config": { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + "insight_type_config": { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" } } - request_init["recommender_config"] = { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config", - "recommender_generation_config": {"params": {"fields": {}}}, + request_init["insight_type_config"] = { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config", + "insight_type_generation_config": {"params": {"fields": {}}}, "etag": "etag_value", "update_time": {"seconds": 751, "nanos": 543}, "revision_id": "revision_id_value", @@ -7317,10 +8502,10 @@ def test_update_recommender_config_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.update_recommender_config(request) + client.update_insight_type_config(request) -def test_update_recommender_config_rest_flattened(): +def test_update_insight_type_config_rest_flattened(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -7329,18 +8514,18 @@ def test_update_recommender_config_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 = gcr_recommender_config.RecommenderConfig() + return_value = gcr_insight_type_config.InsightTypeConfig() # get arguments that satisfy an http rule for this method sample_request = { - "recommender_config": { - "name": "projects/sample1/locations/sample2/recommenders/sample3/config" + "insight_type_config": { + "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" } } # get truthy value for each flattened field mock_args = dict( - recommender_config=gcr_recommender_config.RecommenderConfig( + insight_type_config=gcr_insight_type_config.InsightTypeConfig( name="name_value" ), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), @@ -7350,25 +8535,25 @@ def test_update_recommender_config_rest_flattened(): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = gcr_recommender_config.RecommenderConfig.pb(return_value) + pb_return_value = gcr_insight_type_config.InsightTypeConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.update_recommender_config(**mock_args) + client.update_insight_type_config(**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/v1beta1/{recommender_config.name=projects/*/locations/*/recommenders/*/config}" + "%s/v1beta1/{insight_type_config.name=projects/*/locations/*/insightTypes/*/config}" % client.transport._host, args[1], ) -def test_update_recommender_config_rest_flattened_error(transport: str = "rest"): +def test_update_insight_type_config_rest_flattened_error(transport: str = "rest"): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -7377,16 +8562,16 @@ def test_update_recommender_config_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_recommender_config( - recommender_service.UpdateRecommenderConfigRequest(), - recommender_config=gcr_recommender_config.RecommenderConfig( + client.update_insight_type_config( + recommender_service.UpdateInsightTypeConfigRequest(), + insight_type_config=gcr_insight_type_config.InsightTypeConfig( name="name_value" ), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_recommender_config_rest_error(): +def test_update_insight_type_config_rest_error(): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -7395,138 +8580,44 @@ def test_update_recommender_config_rest_error(): @pytest.mark.parametrize( "request_type", [ - recommender_service.GetInsightTypeConfigRequest, + recommender_service.ListRecommendersRequest, dict, ], ) -def test_get_insight_type_config_rest(request_type): +def test_list_recommenders_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" - } + 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 = insight_type_config.InsightTypeConfig( - name="name_value", - etag="etag_value", - revision_id="revision_id_value", - display_name="display_name_value", + return_value = recommender_service.ListRecommendersResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = insight_type_config.InsightTypeConfig.pb(return_value) + pb_return_value = recommender_service.ListRecommendersResponse.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_insight_type_config(request) + response = client.list_recommenders(request) # Establish that the response is the type that we expect. - assert isinstance(response, insight_type_config.InsightTypeConfig) - assert response.name == "name_value" - assert response.etag == "etag_value" - assert response.revision_id == "revision_id_value" - assert response.display_name == "display_name_value" - - -def test_get_insight_type_config_rest_required_fields( - request_type=recommender_service.GetInsightTypeConfigRequest, -): - transport_class = transports.RecommenderRestTransport - - 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, - including_default_value_fields=False, - use_integers_for_enums=False, - ) - ) - - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_insight_type_config._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_insight_type_config._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" - - client = RecommenderClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = insight_type_config.InsightTypeConfig() - # 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 - - pb_return_value = insight_type_config.InsightTypeConfig.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - response = client.get_insight_type_config(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_get_insight_type_config_rest_unset_required_fields(): - transport = transports.RecommenderRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.get_insight_type_config._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + assert isinstance(response, pagers.ListRecommendersPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_insight_type_config_rest_interceptors(null_interceptor): +def test_list_recommenders_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -7539,14 +8630,14 @@ def test_get_insight_type_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_get_insight_type_config" + transports.RecommenderRestInterceptor, "post_list_recommenders" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_get_insight_type_config" + transports.RecommenderRestInterceptor, "pre_list_recommenders" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.GetInsightTypeConfigRequest.pb( - recommender_service.GetInsightTypeConfigRequest() + pb_message = recommender_service.ListRecommendersRequest.pb( + recommender_service.ListRecommendersRequest() ) transcode.return_value = { "method": "post", @@ -7558,19 +8649,21 @@ def test_get_insight_type_config_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = insight_type_config.InsightTypeConfig.to_json( - insight_type_config.InsightTypeConfig() + req.return_value._content = ( + recommender_service.ListRecommendersResponse.to_json( + recommender_service.ListRecommendersResponse() + ) ) - request = recommender_service.GetInsightTypeConfigRequest() + request = recommender_service.ListRecommendersRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = insight_type_config.InsightTypeConfig() + post.return_value = recommender_service.ListRecommendersResponse() - client.get_insight_type_config( + client.list_recommenders( request, metadata=[ ("key", "val"), @@ -7582,9 +8675,8 @@ def test_get_insight_type_config_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_insight_type_config_rest_bad_request( - transport: str = "rest", - request_type=recommender_service.GetInsightTypeConfigRequest, +def test_list_recommenders_rest_bad_request( + transport: str = "rest", request_type=recommender_service.ListRecommendersRequest ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -7592,9 +8684,7 @@ def test_get_insight_type_config_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" - } + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -7606,230 +8696,113 @@ def test_get_insight_type_config_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_insight_type_config(request) + client.list_recommenders(request) -def test_get_insight_type_config_rest_flattened(): +def test_list_recommenders_rest_pager(transport: str = "rest"): client = RecommenderClient( 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 = insight_type_config.InsightTypeConfig() - - # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" - } - - # 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 - pb_return_value = insight_type_config.InsightTypeConfig.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.get_insight_type_config(**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/v1beta1/{name=projects/*/locations/*/insightTypes/*/config}" - % 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 = ( + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + next_page_token="abc", + ), + recommender_service.ListRecommendersResponse( + recommenders=[], + next_page_token="def", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + ], + next_page_token="ghi", + ), + recommender_service.ListRecommendersResponse( + recommenders=[ + recommendation.RecommenderType(), + recommendation.RecommenderType(), + ], + ), ) + # Two responses for two calls + response = response + response - -def test_get_insight_type_config_rest_flattened_error(transport: str = "rest"): - client = RecommenderClient( - 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_insight_type_config( - recommender_service.GetInsightTypeConfigRequest(), - name="name_value", + # Wrap the values into proper Response objs + response = tuple( + recommender_service.ListRecommendersResponse.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 = {} -def test_get_insight_type_config_rest_error(): - client = RecommenderClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + pager = client.list_recommenders(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, recommendation.RecommenderType) for i in results) + + pages = list(client.list_recommenders(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", [ - recommender_service.UpdateInsightTypeConfigRequest, + recommender_service.ListInsightTypesRequest, dict, ], ) -def test_update_insight_type_config_rest(request_type): +def test_list_insight_types_rest(request_type): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = { - "insight_type_config": { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" - } - } - request_init["insight_type_config"] = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config", - "insight_type_generation_config": {"params": {"fields": {}}}, - "etag": "etag_value", - "update_time": {"seconds": 751, "nanos": 543}, - "revision_id": "revision_id_value", - "annotations": {}, - "display_name": "display_name_value", - } + 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 = gcr_insight_type_config.InsightTypeConfig( - name="name_value", - etag="etag_value", - revision_id="revision_id_value", - display_name="display_name_value", + return_value = recommender_service.ListInsightTypesResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = gcr_insight_type_config.InsightTypeConfig.pb(return_value) + pb_return_value = recommender_service.ListInsightTypesResponse.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_insight_type_config(request) + response = client.list_insight_types(request) # Establish that the response is the type that we expect. - assert isinstance(response, gcr_insight_type_config.InsightTypeConfig) - assert response.name == "name_value" - assert response.etag == "etag_value" - assert response.revision_id == "revision_id_value" - assert response.display_name == "display_name_value" - - -def test_update_insight_type_config_rest_required_fields( - request_type=recommender_service.UpdateInsightTypeConfigRequest, -): - transport_class = transports.RecommenderRestTransport - - request_init = {} - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson( - pb_request, - including_default_value_fields=False, - use_integers_for_enums=False, - ) - ) - - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_insight_type_config._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_insight_type_config._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "update_mask", - "validate_only", - ) - ) - jsonified_request.update(unset_fields) - - # verify required fields with non-default values are left alone - - client = RecommenderClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = gcr_insight_type_config.InsightTypeConfig() - # 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": "patch", - "query_params": pb_request, - } - transcode_result["body"] = pb_request - transcode.return_value = transcode_result - - response_value = Response() - response_value.status_code = 200 - - pb_return_value = gcr_insight_type_config.InsightTypeConfig.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - response = client.update_insight_type_config(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_update_insight_type_config_rest_unset_required_fields(): - transport = transports.RecommenderRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.update_insight_type_config._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "updateMask", - "validateOnly", - ) - ) - & set(("insightTypeConfig",)) - ) + assert isinstance(response, pagers.ListInsightTypesPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_insight_type_config_rest_interceptors(null_interceptor): +def test_list_insight_types_rest_interceptors(null_interceptor): transport = transports.RecommenderRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -7842,14 +8815,14 @@ def test_update_insight_type_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.RecommenderRestInterceptor, "post_update_insight_type_config" + transports.RecommenderRestInterceptor, "post_list_insight_types" ) as post, mock.patch.object( - transports.RecommenderRestInterceptor, "pre_update_insight_type_config" + transports.RecommenderRestInterceptor, "pre_list_insight_types" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = recommender_service.UpdateInsightTypeConfigRequest.pb( - recommender_service.UpdateInsightTypeConfigRequest() + pb_message = recommender_service.ListInsightTypesRequest.pb( + recommender_service.ListInsightTypesRequest() ) transcode.return_value = { "method": "post", @@ -7861,19 +8834,21 @@ def test_update_insight_type_config_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = gcr_insight_type_config.InsightTypeConfig.to_json( - gcr_insight_type_config.InsightTypeConfig() + req.return_value._content = ( + recommender_service.ListInsightTypesResponse.to_json( + recommender_service.ListInsightTypesResponse() + ) ) - request = recommender_service.UpdateInsightTypeConfigRequest() + request = recommender_service.ListInsightTypesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gcr_insight_type_config.InsightTypeConfig() + post.return_value = recommender_service.ListInsightTypesResponse() - client.update_insight_type_config( + client.list_insight_types( request, metadata=[ ("key", "val"), @@ -7885,9 +8860,8 @@ def test_update_insight_type_config_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_insight_type_config_rest_bad_request( - transport: str = "rest", - request_type=recommender_service.UpdateInsightTypeConfigRequest, +def test_list_insight_types_rest_bad_request( + transport: str = "rest", request_type=recommender_service.ListInsightTypesRequest ): client = RecommenderClient( credentials=ga_credentials.AnonymousCredentials(), @@ -7895,20 +8869,7 @@ def test_update_insight_type_config_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = { - "insight_type_config": { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" - } - } - request_init["insight_type_config"] = { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config", - "insight_type_generation_config": {"params": {"fields": {}}}, - "etag": "etag_value", - "update_time": {"seconds": 751, "nanos": 543}, - "revision_id": "revision_id_value", - "annotations": {}, - "display_name": "display_name_value", - } + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -7920,79 +8881,70 @@ def test_update_insight_type_config_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.update_insight_type_config(request) + client.list_insight_types(request) -def test_update_insight_type_config_rest_flattened(): +def test_list_insight_types_rest_pager(transport: str = "rest"): client = RecommenderClient( 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 = gcr_insight_type_config.InsightTypeConfig() - - # get arguments that satisfy an http rule for this method - sample_request = { - "insight_type_config": { - "name": "projects/sample1/locations/sample2/insightTypes/sample3/config" - } - } - - # get truthy value for each flattened field - mock_args = dict( - insight_type_config=gcr_insight_type_config.InsightTypeConfig( - name="name_value" + 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 = ( + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + insight.InsightType(), + ], + next_page_token="abc", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[], + next_page_token="def", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + ], + next_page_token="ghi", + ), + recommender_service.ListInsightTypesResponse( + insight_types=[ + insight.InsightType(), + insight.InsightType(), + ], ), - 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 - pb_return_value = gcr_insight_type_config.InsightTypeConfig.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - - client.update_insight_type_config(**mock_args) + # Two responses for two calls + response = response + response - # 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/v1beta1/{insight_type_config.name=projects/*/locations/*/insightTypes/*/config}" - % client.transport._host, - args[1], + # Wrap the values into proper Response objs + response = tuple( + recommender_service.ListInsightTypesResponse.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 = {} -def test_update_insight_type_config_rest_flattened_error(transport: str = "rest"): - client = RecommenderClient( - 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_insight_type_config( - recommender_service.UpdateInsightTypeConfigRequest(), - insight_type_config=gcr_insight_type_config.InsightTypeConfig( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) + pager = client.list_insight_types(request=sample_request) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, insight.InsightType) for i in results) -def test_update_insight_type_config_rest_error(): - client = RecommenderClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + pages = list(client.list_insight_types(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(): @@ -8146,6 +9098,8 @@ def test_recommender_base_transport(): "update_recommender_config", "get_insight_type_config", "update_insight_type_config", + "list_recommenders", + "list_insight_types", ) for method in methods: with pytest.raises(NotImplementedError): @@ -8437,6 +9391,12 @@ def test_recommender_client_transport_session_collision(transport_name): session1 = client1.transport.update_insight_type_config._session session2 = client2.transport.update_insight_type_config._session assert session1 != session2 + session1 = client1.transport.list_recommenders._session + session2 = client2.transport.list_recommenders._session + assert session1 != session2 + session1 = client1.transport.list_insight_types._session + session2 = client2.transport.list_insight_types._session + assert session1 != session2 def test_recommender_grpc_transport_channel():