diff --git a/.librarian/state.yaml b/.librarian/state.yaml index addf1c7a7908..55d1826b294a 100644 --- a/.librarian/state.yaml +++ b/.librarian/state.yaml @@ -21,7 +21,7 @@ libraries: tag_format: '{id}-v{version}' - id: google-ads-marketingplatform-admin version: 0.2.0 - last_generated_commit: 3322511885371d2b2253f209ccc3aa60d4100cfd + last_generated_commit: b6bb60733a7314d0c45e294b12d563fd6194b8f5 apis: - path: google/marketingplatform/admin/v1alpha service_config: marketingplatformadmin_v1alpha.yaml @@ -1182,7 +1182,7 @@ libraries: tag_format: '{id}-v{version}' - id: google-cloud-cloudsecuritycompliance version: 0.3.0 - last_generated_commit: 72e7439c8e7e9986cf1865e337fc7c64ca5bda1f + last_generated_commit: b6bb60733a7314d0c45e294b12d563fd6194b8f5 apis: - path: google/cloud/cloudsecuritycompliance/v1 service_config: cloudsecuritycompliance_v1.yaml @@ -2700,7 +2700,7 @@ libraries: tag_format: '{id}-v{version}' - id: google-cloud-network-management version: 1.29.0 - last_generated_commit: 3322511885371d2b2253f209ccc3aa60d4100cfd + last_generated_commit: b6bb60733a7314d0c45e294b12d563fd6194b8f5 apis: - path: google/cloud/networkmanagement/v1 service_config: networkmanagement_v1.yaml diff --git a/packages/google-ads-marketingplatform-admin/.repo-metadata.json b/packages/google-ads-marketingplatform-admin/.repo-metadata.json index 43e0ec21bcf3..dff8916f4631 100644 --- a/packages/google-ads-marketingplatform-admin/.repo-metadata.json +++ b/packages/google-ads-marketingplatform-admin/.repo-metadata.json @@ -1,16 +1,16 @@ { - "name": "google-ads-marketingplatform-admin", - "name_pretty": "Google Marketing Platform Admin API", - "api_description": "The Google Marketing Platform Admin API allows for programmatic access to the Google Marketing Platform configuration data. You can use the Google Marketing Platform Admin API to manage links between your Google Marketing Platform organization and Google Analytics accounts, and to set the service level of your GA4 properties.", - "product_documentation": "https://developers.google.com/analytics/devguides/config/gmp/v1", - "client_documentation": "https://googleapis.dev/python/google-ads-marketingplatform-admin/latest", - "issue_tracker": "https://github.com/googleapis/google-cloud-python/issues", - "release_level": "preview", - "language": "python", - "library_type": "GAPIC_AUTO", - "repo": "googleapis/google-cloud-python", - "distribution_name": "google-ads-marketingplatform-admin", - "api_id": "marketingplatformadmin.googleapis.com", - "default_version": "v1alpha", - "api_shortname": "marketingplatformadmin" -} \ No newline at end of file + "name": "google-ads-marketingplatform-admin", + "name_pretty": "Google Marketing Platform Admin API", + "api_description": "The Google Marketing Platform Admin API allows for programmatic access to\nthe Google Marketing Platform configuration data. You can use the Google\nMarketing Platform Admin API to manage links between your Google Marketing\nPlatform organization and Google Analytics accounts, and to set the\nservice level of your GA4 properties.", + "product_documentation": "https://developers.google.com/analytics/devguides/config/gmp/v1", + "client_documentation": "https://cloud.google.com/python/docs/reference/google-ads-marketingplatform-admin/latest", + "issue_tracker": "https://issuetracker.google.com/issues/new?component=1603054", + "release_level": "preview", + "language": "python", + "library_type": "GAPIC_AUTO", + "repo": "googleapis/google-cloud-python", + "distribution_name": "google-ads-marketingplatform-admin", + "api_id": "marketingplatformadmin.googleapis.com", + "default_version": "v1alpha", + "api_shortname": "marketingplatformadmin" +} diff --git a/packages/google-ads-marketingplatform-admin/README.rst b/packages/google-ads-marketingplatform-admin/README.rst index 0b105091d2da..7abf47025249 100644 --- a/packages/google-ads-marketingplatform-admin/README.rst +++ b/packages/google-ads-marketingplatform-admin/README.rst @@ -3,7 +3,11 @@ Python Client for Google Marketing Platform Admin API |preview| |pypi| |versions| -`Google Marketing Platform Admin API`_: The Google Marketing Platform Admin API allows for programmatic access to the Google Marketing Platform configuration data. You can use the Google Marketing Platform Admin API to manage links between your Google Marketing Platform organization and Google Analytics accounts, and to set the service level of your GA4 properties. +`Google Marketing Platform Admin API`_: The Google Marketing Platform Admin API allows for programmatic access to +the Google Marketing Platform configuration data. You can use the Google +Marketing Platform Admin API to manage links between your Google Marketing +Platform organization and Google Analytics accounts, and to set the +service level of your GA4 properties. - `Client Library Documentation`_ - `Product Documentation`_ @@ -15,7 +19,7 @@ Python Client for Google Marketing Platform Admin API .. |versions| image:: https://img.shields.io/pypi/pyversions/google-ads-marketingplatform-admin.svg :target: https://pypi.org/project/google-ads-marketingplatform-admin/ .. _Google Marketing Platform Admin API: https://developers.google.com/analytics/devguides/config/gmp/v1 -.. _Client Library Documentation: https://googleapis.dev/python/google-ads-marketingplatform-admin/latest +.. _Client Library Documentation: https://cloud.google.com/python/docs/reference/google-ads-marketingplatform-admin/latest .. _Product Documentation: https://developers.google.com/analytics/devguides/config/gmp/v1 Quick Start diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin/__init__.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin/__init__.py index 4da1f9d4d206..30d9d0dcb7a8 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin/__init__.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin/__init__.py @@ -25,17 +25,24 @@ MarketingplatformAdminServiceClient, ) from google.ads.marketingplatform_admin_v1alpha.types.marketingplatform_admin import ( - AnalyticsServiceLevel, CreateAnalyticsAccountLinkRequest, DeleteAnalyticsAccountLinkRequest, + FindSalesPartnerManagedClientsRequest, + FindSalesPartnerManagedClientsResponse, GetOrganizationRequest, ListAnalyticsAccountLinksRequest, ListAnalyticsAccountLinksResponse, + ListOrganizationsRequest, + ListOrganizationsResponse, + ReportPropertyUsageRequest, + ReportPropertyUsageResponse, SetPropertyServiceLevelRequest, SetPropertyServiceLevelResponse, ) from google.ads.marketingplatform_admin_v1alpha.types.resources import ( AnalyticsAccountLink, + AnalyticsPropertyType, + AnalyticsServiceLevel, LinkVerificationState, Organization, ) @@ -45,13 +52,20 @@ "MarketingplatformAdminServiceAsyncClient", "CreateAnalyticsAccountLinkRequest", "DeleteAnalyticsAccountLinkRequest", + "FindSalesPartnerManagedClientsRequest", + "FindSalesPartnerManagedClientsResponse", "GetOrganizationRequest", "ListAnalyticsAccountLinksRequest", "ListAnalyticsAccountLinksResponse", + "ListOrganizationsRequest", + "ListOrganizationsResponse", + "ReportPropertyUsageRequest", + "ReportPropertyUsageResponse", "SetPropertyServiceLevelRequest", "SetPropertyServiceLevelResponse", - "AnalyticsServiceLevel", "AnalyticsAccountLink", "Organization", + "AnalyticsPropertyType", + "AnalyticsServiceLevel", "LinkVerificationState", ) diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/__init__.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/__init__.py index dec3156333f7..f423719e2827 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/__init__.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/__init__.py @@ -23,29 +23,47 @@ MarketingplatformAdminServiceClient, ) from .types.marketingplatform_admin import ( - AnalyticsServiceLevel, CreateAnalyticsAccountLinkRequest, DeleteAnalyticsAccountLinkRequest, + FindSalesPartnerManagedClientsRequest, + FindSalesPartnerManagedClientsResponse, GetOrganizationRequest, ListAnalyticsAccountLinksRequest, ListAnalyticsAccountLinksResponse, + ListOrganizationsRequest, + ListOrganizationsResponse, + ReportPropertyUsageRequest, + ReportPropertyUsageResponse, SetPropertyServiceLevelRequest, SetPropertyServiceLevelResponse, ) -from .types.resources import AnalyticsAccountLink, LinkVerificationState, Organization +from .types.resources import ( + AnalyticsAccountLink, + AnalyticsPropertyType, + AnalyticsServiceLevel, + LinkVerificationState, + Organization, +) __all__ = ( "MarketingplatformAdminServiceAsyncClient", "AnalyticsAccountLink", + "AnalyticsPropertyType", "AnalyticsServiceLevel", "CreateAnalyticsAccountLinkRequest", "DeleteAnalyticsAccountLinkRequest", + "FindSalesPartnerManagedClientsRequest", + "FindSalesPartnerManagedClientsResponse", "GetOrganizationRequest", "LinkVerificationState", "ListAnalyticsAccountLinksRequest", "ListAnalyticsAccountLinksResponse", + "ListOrganizationsRequest", + "ListOrganizationsResponse", "MarketingplatformAdminServiceClient", "Organization", + "ReportPropertyUsageRequest", + "ReportPropertyUsageResponse", "SetPropertyServiceLevelRequest", "SetPropertyServiceLevelResponse", ) diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/gapic_metadata.json b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/gapic_metadata.json index 8d346e91ed67..7378e8a813a2 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/gapic_metadata.json +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/gapic_metadata.json @@ -20,6 +20,11 @@ "delete_analytics_account_link" ] }, + "FindSalesPartnerManagedClients": { + "methods": [ + "find_sales_partner_managed_clients" + ] + }, "GetOrganization": { "methods": [ "get_organization" @@ -30,6 +35,16 @@ "list_analytics_account_links" ] }, + "ListOrganizations": { + "methods": [ + "list_organizations" + ] + }, + "ReportPropertyUsage": { + "methods": [ + "report_property_usage" + ] + }, "SetPropertyServiceLevel": { "methods": [ "set_property_service_level" @@ -50,6 +65,11 @@ "delete_analytics_account_link" ] }, + "FindSalesPartnerManagedClients": { + "methods": [ + "find_sales_partner_managed_clients" + ] + }, "GetOrganization": { "methods": [ "get_organization" @@ -60,6 +80,16 @@ "list_analytics_account_links" ] }, + "ListOrganizations": { + "methods": [ + "list_organizations" + ] + }, + "ReportPropertyUsage": { + "methods": [ + "report_property_usage" + ] + }, "SetPropertyServiceLevel": { "methods": [ "set_property_service_level" @@ -80,6 +110,11 @@ "delete_analytics_account_link" ] }, + "FindSalesPartnerManagedClients": { + "methods": [ + "find_sales_partner_managed_clients" + ] + }, "GetOrganization": { "methods": [ "get_organization" @@ -90,6 +125,16 @@ "list_analytics_account_links" ] }, + "ListOrganizations": { + "methods": [ + "list_organizations" + ] + }, + "ReportPropertyUsage": { + "methods": [ + "report_property_usage" + ] + }, "SetPropertyServiceLevel": { "methods": [ "set_property_service_level" diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/async_client.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/async_client.py index a8879c58fff9..1416ba2380b8 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/async_client.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/async_client.py @@ -437,6 +437,200 @@ async def sample_get_organization(): # Done; return the response. return response + async def list_organizations( + self, + request: Optional[ + Union[marketingplatform_admin.ListOrganizationsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListOrganizationsAsyncPager: + r"""Returns a list of organizations that the user has + access to. + + .. 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.ads import marketingplatform_admin_v1alpha + + async def sample_list_organizations(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ListOrganizationsRequest( + ) + + # Make the request + page_result = client.list_organizations(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsRequest, dict]]): + The request object. Request message for ListOrganizations + RPC. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.ads.marketingplatform_admin_v1alpha.services.marketingplatform_admin_service.pagers.ListOrganizationsAsyncPager: + Response message for + ListOrganizations RPC. + Iterating over this object will yield + results and resolve additional pages + automatically. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, marketingplatform_admin.ListOrganizationsRequest): + request = marketingplatform_admin.ListOrganizationsRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.list_organizations + ] + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListOrganizationsAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def find_sales_partner_managed_clients( + self, + request: Optional[ + Union[marketingplatform_admin.FindSalesPartnerManagedClientsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.FindSalesPartnerManagedClientsResponse: + r"""Returns a list of clients managed by the sales + partner organization. + User needs to be an OrgAdmin/BillingAdmin on the sales + partner organization in order to view the end clients. + + .. 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.ads import marketingplatform_admin_v1alpha + + async def sample_find_sales_partner_managed_clients(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.FindSalesPartnerManagedClientsRequest( + organization="organization_value", + ) + + # Make the request + response = await client.find_sales_partner_managed_clients(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsRequest, dict]]): + The request object. Request message for + FindSalesPartnerManagedClients RPC. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsResponse: + Response message for + FindSalesPartnerManagedClients RPC. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance( + request, marketingplatform_admin.FindSalesPartnerManagedClientsRequest + ): + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest( + request + ) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.find_sales_partner_managed_clients + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("organization", request.organization),) + ), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + async def list_analytics_account_links( self, request: Optional[ @@ -937,6 +1131,135 @@ async def sample_set_property_service_level(): # Done; return the response. return response + async def report_property_usage( + self, + request: Optional[ + Union[marketingplatform_admin.ReportPropertyUsageRequest, dict] + ] = None, + *, + organization: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.ReportPropertyUsageResponse: + r"""Get the usage and billing data for properties within + the organization for the specified month. + + Per direct client org, user needs to be + OrgAdmin/BillingAdmin on the organization in order to + view the billing and usage data. + + Per sales partner client org, user needs to be + OrgAdmin/BillingAdmin on the sales partner org in order + to view the billing and usage data, or + OrgAdmin/BillingAdmin on the sales partner client org in + order to view the usage data only. + + .. 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.ads import marketingplatform_admin_v1alpha + + async def sample_report_property_usage(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ReportPropertyUsageRequest( + organization="organization_value", + month="month_value", + ) + + # Make the request + response = await client.report_property_usage(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageRequest, dict]]): + The request object. Request message for + ReportPropertyUsage RPC. + organization (:class:`str`): + Required. Specifies the organization whose property + usage will be listed. + + Format: organizations/{org_id} + + This corresponds to the ``organization`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageResponse: + Response message for + ReportPropertyUsage RPC. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [organization] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, marketingplatform_admin.ReportPropertyUsageRequest): + request = marketingplatform_admin.ReportPropertyUsageRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if organization is not None: + request.organization = organization + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.report_property_usage + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("organization", request.organization),) + ), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + async def __aenter__(self) -> "MarketingplatformAdminServiceAsyncClient": return self diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/client.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/client.py index fdeee05657d8..b2f9bbfd003b 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/client.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/client.py @@ -889,6 +889,198 @@ def sample_get_organization(): # Done; return the response. return response + def list_organizations( + self, + request: Optional[ + Union[marketingplatform_admin.ListOrganizationsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListOrganizationsPager: + r"""Returns a list of organizations that the user has + access to. + + .. 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.ads import marketingplatform_admin_v1alpha + + def sample_list_organizations(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ListOrganizationsRequest( + ) + + # Make the request + page_result = client.list_organizations(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsRequest, dict]): + The request object. Request message for ListOrganizations + RPC. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.ads.marketingplatform_admin_v1alpha.services.marketingplatform_admin_service.pagers.ListOrganizationsPager: + Response message for + ListOrganizations RPC. + Iterating over this object will yield + results and resolve additional pages + automatically. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, marketingplatform_admin.ListOrganizationsRequest): + request = marketingplatform_admin.ListOrganizationsRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_organizations] + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListOrganizationsPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def find_sales_partner_managed_clients( + self, + request: Optional[ + Union[marketingplatform_admin.FindSalesPartnerManagedClientsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.FindSalesPartnerManagedClientsResponse: + r"""Returns a list of clients managed by the sales + partner organization. + User needs to be an OrgAdmin/BillingAdmin on the sales + partner organization in order to view the end clients. + + .. 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.ads import marketingplatform_admin_v1alpha + + def sample_find_sales_partner_managed_clients(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.FindSalesPartnerManagedClientsRequest( + organization="organization_value", + ) + + # Make the request + response = client.find_sales_partner_managed_clients(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsRequest, dict]): + The request object. Request message for + FindSalesPartnerManagedClients RPC. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsResponse: + Response message for + FindSalesPartnerManagedClients RPC. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance( + request, marketingplatform_admin.FindSalesPartnerManagedClientsRequest + ): + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest( + request + ) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.find_sales_partner_managed_clients + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("organization", request.organization),) + ), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + def list_analytics_account_links( self, request: Optional[ @@ -1385,6 +1577,132 @@ def sample_set_property_service_level(): # Done; return the response. return response + def report_property_usage( + self, + request: Optional[ + Union[marketingplatform_admin.ReportPropertyUsageRequest, dict] + ] = None, + *, + organization: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.ReportPropertyUsageResponse: + r"""Get the usage and billing data for properties within + the organization for the specified month. + + Per direct client org, user needs to be + OrgAdmin/BillingAdmin on the organization in order to + view the billing and usage data. + + Per sales partner client org, user needs to be + OrgAdmin/BillingAdmin on the sales partner org in order + to view the billing and usage data, or + OrgAdmin/BillingAdmin on the sales partner client org in + order to view the usage data only. + + .. 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.ads import marketingplatform_admin_v1alpha + + def sample_report_property_usage(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ReportPropertyUsageRequest( + organization="organization_value", + month="month_value", + ) + + # Make the request + response = client.report_property_usage(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageRequest, dict]): + The request object. Request message for + ReportPropertyUsage RPC. + organization (str): + Required. Specifies the organization whose property + usage will be listed. + + Format: organizations/{org_id} + + This corresponds to the ``organization`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageResponse: + Response message for + ReportPropertyUsage RPC. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [organization] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, marketingplatform_admin.ReportPropertyUsageRequest): + request = marketingplatform_admin.ReportPropertyUsageRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if organization is not None: + request.organization = organization + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.report_property_usage] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("organization", request.organization),) + ), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + def __enter__(self) -> "MarketingplatformAdminServiceClient": return self diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/pagers.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/pagers.py index 0436ed0b0d73..f31c78893a3a 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/pagers.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/pagers.py @@ -44,6 +44,166 @@ ) +class ListOrganizationsPager: + """A pager for iterating through ``list_organizations`` requests. + + This class thinly wraps an initial + :class:`google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``organizations`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListOrganizations`` requests and continue to iterate + through the ``organizations`` field on the + corresponding responses. + + All the usual :class:`google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsResponse` + 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[..., marketingplatform_admin.ListOrganizationsResponse], + request: marketingplatform_admin.ListOrganizationsRequest, + response: marketingplatform_admin.ListOrganizationsResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsRequest): + The initial request object. + response (google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = marketingplatform_admin.ListOrganizationsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[marketingplatform_admin.ListOrganizationsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[resources.Organization]: + for page in self.pages: + yield from page.organizations + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListOrganizationsAsyncPager: + """A pager for iterating through ``list_organizations`` requests. + + This class thinly wraps an initial + :class:`google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``organizations`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListOrganizations`` requests and continue to iterate + through the ``organizations`` field on the + corresponding responses. + + All the usual :class:`google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsResponse` + 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[marketingplatform_admin.ListOrganizationsResponse] + ], + request: marketingplatform_admin.ListOrganizationsRequest, + response: marketingplatform_admin.ListOrganizationsResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsRequest): + The initial request object. + response (google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = marketingplatform_admin.ListOrganizationsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[marketingplatform_admin.ListOrganizationsResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__(self) -> AsyncIterator[resources.Organization]: + async def async_generator(): + async for page in self.pages: + for response in page.organizations: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + class ListAnalyticsAccountLinksPager: """A pager for iterating through ``list_analytics_account_links`` requests. diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/base.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/base.py index a0fa7888d09d..a4edc5f2ed0b 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/base.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/base.py @@ -145,6 +145,16 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.list_organizations: gapic_v1.method.wrap_method( + self.list_organizations, + default_timeout=None, + client_info=client_info, + ), + self.find_sales_partner_managed_clients: gapic_v1.method.wrap_method( + self.find_sales_partner_managed_clients, + default_timeout=None, + client_info=client_info, + ), self.list_analytics_account_links: gapic_v1.method.wrap_method( self.list_analytics_account_links, default_timeout=None, @@ -165,6 +175,11 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.report_property_usage: gapic_v1.method.wrap_method( + self.report_property_usage, + default_timeout=None, + client_info=client_info, + ), } def close(self): @@ -185,6 +200,30 @@ def get_organization( ]: raise NotImplementedError() + @property + def list_organizations( + self, + ) -> Callable[ + [marketingplatform_admin.ListOrganizationsRequest], + Union[ + marketingplatform_admin.ListOrganizationsResponse, + Awaitable[marketingplatform_admin.ListOrganizationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def find_sales_partner_managed_clients( + self, + ) -> Callable[ + [marketingplatform_admin.FindSalesPartnerManagedClientsRequest], + Union[ + marketingplatform_admin.FindSalesPartnerManagedClientsResponse, + Awaitable[marketingplatform_admin.FindSalesPartnerManagedClientsResponse], + ], + ]: + raise NotImplementedError() + @property def list_analytics_account_links( self, @@ -229,6 +268,18 @@ def set_property_service_level( ]: raise NotImplementedError() + @property + def report_property_usage( + self, + ) -> Callable[ + [marketingplatform_admin.ReportPropertyUsageRequest], + Union[ + marketingplatform_admin.ReportPropertyUsageResponse, + Awaitable[marketingplatform_admin.ReportPropertyUsageResponse], + ], + ]: + raise NotImplementedError() + @property def kind(self) -> str: raise NotImplementedError() diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc.py index 97c4e79c239b..571481963ff7 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc.py @@ -356,6 +356,71 @@ def get_organization( ) return self._stubs["get_organization"] + @property + def list_organizations( + self, + ) -> Callable[ + [marketingplatform_admin.ListOrganizationsRequest], + marketingplatform_admin.ListOrganizationsResponse, + ]: + r"""Return a callable for the list organizations method over gRPC. + + Returns a list of organizations that the user has + access to. + + Returns: + Callable[[~.ListOrganizationsRequest], + ~.ListOrganizationsResponse]: + 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_organizations" not in self._stubs: + self._stubs["list_organizations"] = self._logged_channel.unary_unary( + "/google.marketingplatform.admin.v1alpha.MarketingplatformAdminService/ListOrganizations", + request_serializer=marketingplatform_admin.ListOrganizationsRequest.serialize, + response_deserializer=marketingplatform_admin.ListOrganizationsResponse.deserialize, + ) + return self._stubs["list_organizations"] + + @property + def find_sales_partner_managed_clients( + self, + ) -> Callable[ + [marketingplatform_admin.FindSalesPartnerManagedClientsRequest], + marketingplatform_admin.FindSalesPartnerManagedClientsResponse, + ]: + r"""Return a callable for the find sales partner managed + clients method over gRPC. + + Returns a list of clients managed by the sales + partner organization. + User needs to be an OrgAdmin/BillingAdmin on the sales + partner organization in order to view the end clients. + + Returns: + Callable[[~.FindSalesPartnerManagedClientsRequest], + ~.FindSalesPartnerManagedClientsResponse]: + 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 "find_sales_partner_managed_clients" not in self._stubs: + self._stubs[ + "find_sales_partner_managed_clients" + ] = self._logged_channel.unary_unary( + "/google.marketingplatform.admin.v1alpha.MarketingplatformAdminService/FindSalesPartnerManagedClients", + request_serializer=marketingplatform_admin.FindSalesPartnerManagedClientsRequest.serialize, + response_deserializer=marketingplatform_admin.FindSalesPartnerManagedClientsResponse.deserialize, + ) + return self._stubs["find_sales_partner_managed_clients"] + @property def list_analytics_account_links( self, @@ -492,6 +557,46 @@ def set_property_service_level( ) return self._stubs["set_property_service_level"] + @property + def report_property_usage( + self, + ) -> Callable[ + [marketingplatform_admin.ReportPropertyUsageRequest], + marketingplatform_admin.ReportPropertyUsageResponse, + ]: + r"""Return a callable for the report property usage method over gRPC. + + Get the usage and billing data for properties within + the organization for the specified month. + + Per direct client org, user needs to be + OrgAdmin/BillingAdmin on the organization in order to + view the billing and usage data. + + Per sales partner client org, user needs to be + OrgAdmin/BillingAdmin on the sales partner org in order + to view the billing and usage data, or + OrgAdmin/BillingAdmin on the sales partner client org in + order to view the usage data only. + + Returns: + Callable[[~.ReportPropertyUsageRequest], + ~.ReportPropertyUsageResponse]: + 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 "report_property_usage" not in self._stubs: + self._stubs["report_property_usage"] = self._logged_channel.unary_unary( + "/google.marketingplatform.admin.v1alpha.MarketingplatformAdminService/ReportPropertyUsage", + request_serializer=marketingplatform_admin.ReportPropertyUsageRequest.serialize, + response_deserializer=marketingplatform_admin.ReportPropertyUsageResponse.deserialize, + ) + return self._stubs["report_property_usage"] + def close(self): self._logged_channel.close() diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc_asyncio.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc_asyncio.py index c7e1801bf6eb..1a99d9895164 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc_asyncio.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/grpc_asyncio.py @@ -365,6 +365,71 @@ def get_organization( ) return self._stubs["get_organization"] + @property + def list_organizations( + self, + ) -> Callable[ + [marketingplatform_admin.ListOrganizationsRequest], + Awaitable[marketingplatform_admin.ListOrganizationsResponse], + ]: + r"""Return a callable for the list organizations method over gRPC. + + Returns a list of organizations that the user has + access to. + + Returns: + Callable[[~.ListOrganizationsRequest], + Awaitable[~.ListOrganizationsResponse]]: + 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_organizations" not in self._stubs: + self._stubs["list_organizations"] = self._logged_channel.unary_unary( + "/google.marketingplatform.admin.v1alpha.MarketingplatformAdminService/ListOrganizations", + request_serializer=marketingplatform_admin.ListOrganizationsRequest.serialize, + response_deserializer=marketingplatform_admin.ListOrganizationsResponse.deserialize, + ) + return self._stubs["list_organizations"] + + @property + def find_sales_partner_managed_clients( + self, + ) -> Callable[ + [marketingplatform_admin.FindSalesPartnerManagedClientsRequest], + Awaitable[marketingplatform_admin.FindSalesPartnerManagedClientsResponse], + ]: + r"""Return a callable for the find sales partner managed + clients method over gRPC. + + Returns a list of clients managed by the sales + partner organization. + User needs to be an OrgAdmin/BillingAdmin on the sales + partner organization in order to view the end clients. + + Returns: + Callable[[~.FindSalesPartnerManagedClientsRequest], + Awaitable[~.FindSalesPartnerManagedClientsResponse]]: + 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 "find_sales_partner_managed_clients" not in self._stubs: + self._stubs[ + "find_sales_partner_managed_clients" + ] = self._logged_channel.unary_unary( + "/google.marketingplatform.admin.v1alpha.MarketingplatformAdminService/FindSalesPartnerManagedClients", + request_serializer=marketingplatform_admin.FindSalesPartnerManagedClientsRequest.serialize, + response_deserializer=marketingplatform_admin.FindSalesPartnerManagedClientsResponse.deserialize, + ) + return self._stubs["find_sales_partner_managed_clients"] + @property def list_analytics_account_links( self, @@ -502,6 +567,46 @@ def set_property_service_level( ) return self._stubs["set_property_service_level"] + @property + def report_property_usage( + self, + ) -> Callable[ + [marketingplatform_admin.ReportPropertyUsageRequest], + Awaitable[marketingplatform_admin.ReportPropertyUsageResponse], + ]: + r"""Return a callable for the report property usage method over gRPC. + + Get the usage and billing data for properties within + the organization for the specified month. + + Per direct client org, user needs to be + OrgAdmin/BillingAdmin on the organization in order to + view the billing and usage data. + + Per sales partner client org, user needs to be + OrgAdmin/BillingAdmin on the sales partner org in order + to view the billing and usage data, or + OrgAdmin/BillingAdmin on the sales partner client org in + order to view the usage data only. + + Returns: + Callable[[~.ReportPropertyUsageRequest], + Awaitable[~.ReportPropertyUsageResponse]]: + 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 "report_property_usage" not in self._stubs: + self._stubs["report_property_usage"] = self._logged_channel.unary_unary( + "/google.marketingplatform.admin.v1alpha.MarketingplatformAdminService/ReportPropertyUsage", + request_serializer=marketingplatform_admin.ReportPropertyUsageRequest.serialize, + response_deserializer=marketingplatform_admin.ReportPropertyUsageResponse.deserialize, + ) + return self._stubs["report_property_usage"] + def _prep_wrapped_messages(self, client_info): """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" self._wrapped_methods = { @@ -510,6 +615,16 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.list_organizations: self._wrap_method( + self.list_organizations, + default_timeout=None, + client_info=client_info, + ), + self.find_sales_partner_managed_clients: self._wrap_method( + self.find_sales_partner_managed_clients, + default_timeout=None, + client_info=client_info, + ), self.list_analytics_account_links: self._wrap_method( self.list_analytics_account_links, default_timeout=None, @@ -530,6 +645,11 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.report_property_usage: self._wrap_method( + self.report_property_usage, + default_timeout=None, + client_info=client_info, + ), } def _wrap_method(self, func, *args, **kwargs): diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest.py index 220347cfc789..81e0d3d51106 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest.py @@ -88,6 +88,14 @@ def pre_delete_analytics_account_link(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata + def pre_find_sales_partner_managed_clients(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_find_sales_partner_managed_clients(self, response): + logging.log(f"Received response: {response}") + return response + def pre_get_organization(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -104,6 +112,22 @@ def post_list_analytics_account_links(self, response): logging.log(f"Received response: {response}") return response + def pre_list_organizations(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_organizations(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_report_property_usage(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_report_property_usage(self, response): + logging.log(f"Received response: {response}") + return response + def pre_set_property_service_level(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -182,6 +206,58 @@ def pre_delete_analytics_account_link( """ return request, metadata + def pre_find_sales_partner_managed_clients( + self, + request: marketingplatform_admin.FindSalesPartnerManagedClientsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + marketingplatform_admin.FindSalesPartnerManagedClientsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for find_sales_partner_managed_clients + + Override in a subclass to manipulate the request or metadata + before they are sent to the MarketingplatformAdminService server. + """ + return request, metadata + + def post_find_sales_partner_managed_clients( + self, response: marketingplatform_admin.FindSalesPartnerManagedClientsResponse + ) -> marketingplatform_admin.FindSalesPartnerManagedClientsResponse: + """Post-rpc interceptor for find_sales_partner_managed_clients + + DEPRECATED. Please use the `post_find_sales_partner_managed_clients_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the MarketingplatformAdminService server but before + it is returned to user code. This `post_find_sales_partner_managed_clients` interceptor runs + before the `post_find_sales_partner_managed_clients_with_metadata` interceptor. + """ + return response + + def post_find_sales_partner_managed_clients_with_metadata( + self, + response: marketingplatform_admin.FindSalesPartnerManagedClientsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + marketingplatform_admin.FindSalesPartnerManagedClientsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for find_sales_partner_managed_clients + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the MarketingplatformAdminService server but before it is returned to user code. + + We recommend only using this `post_find_sales_partner_managed_clients_with_metadata` + interceptor in new development instead of the `post_find_sales_partner_managed_clients` interceptor. + When both interceptors are used, this `post_find_sales_partner_managed_clients_with_metadata` interceptor runs after the + `post_find_sales_partner_managed_clients` interceptor. The (possibly modified) response returned by + `post_find_sales_partner_managed_clients` will be passed to + `post_find_sales_partner_managed_clients_with_metadata`. + """ + return response, metadata + def pre_get_organization( self, request: marketingplatform_admin.GetOrganizationRequest, @@ -283,6 +359,110 @@ def post_list_analytics_account_links_with_metadata( """ return response, metadata + def pre_list_organizations( + self, + request: marketingplatform_admin.ListOrganizationsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + marketingplatform_admin.ListOrganizationsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for list_organizations + + Override in a subclass to manipulate the request or metadata + before they are sent to the MarketingplatformAdminService server. + """ + return request, metadata + + def post_list_organizations( + self, response: marketingplatform_admin.ListOrganizationsResponse + ) -> marketingplatform_admin.ListOrganizationsResponse: + """Post-rpc interceptor for list_organizations + + DEPRECATED. Please use the `post_list_organizations_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the MarketingplatformAdminService server but before + it is returned to user code. This `post_list_organizations` interceptor runs + before the `post_list_organizations_with_metadata` interceptor. + """ + return response + + def post_list_organizations_with_metadata( + self, + response: marketingplatform_admin.ListOrganizationsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + marketingplatform_admin.ListOrganizationsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for list_organizations + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the MarketingplatformAdminService server but before it is returned to user code. + + We recommend only using this `post_list_organizations_with_metadata` + interceptor in new development instead of the `post_list_organizations` interceptor. + When both interceptors are used, this `post_list_organizations_with_metadata` interceptor runs after the + `post_list_organizations` interceptor. The (possibly modified) response returned by + `post_list_organizations` will be passed to + `post_list_organizations_with_metadata`. + """ + return response, metadata + + def pre_report_property_usage( + self, + request: marketingplatform_admin.ReportPropertyUsageRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + marketingplatform_admin.ReportPropertyUsageRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for report_property_usage + + Override in a subclass to manipulate the request or metadata + before they are sent to the MarketingplatformAdminService server. + """ + return request, metadata + + def post_report_property_usage( + self, response: marketingplatform_admin.ReportPropertyUsageResponse + ) -> marketingplatform_admin.ReportPropertyUsageResponse: + """Post-rpc interceptor for report_property_usage + + DEPRECATED. Please use the `post_report_property_usage_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the MarketingplatformAdminService server but before + it is returned to user code. This `post_report_property_usage` interceptor runs + before the `post_report_property_usage_with_metadata` interceptor. + """ + return response + + def post_report_property_usage_with_metadata( + self, + response: marketingplatform_admin.ReportPropertyUsageResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + marketingplatform_admin.ReportPropertyUsageResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for report_property_usage + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the MarketingplatformAdminService server but before it is returned to user code. + + We recommend only using this `post_report_property_usage_with_metadata` + interceptor in new development instead of the `post_report_property_usage` interceptor. + When both interceptors are used, this `post_report_property_usage_with_metadata` interceptor runs after the + `post_report_property_usage` interceptor. The (possibly modified) response returned by + `post_report_property_usage` will be passed to + `post_report_property_usage_with_metadata`. + """ + return response, metadata + def pre_set_property_service_level( self, request: marketingplatform_admin.SetPropertyServiceLevelRequest, @@ -705,6 +885,175 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) + class _FindSalesPartnerManagedClients( + _BaseMarketingplatformAdminServiceRestTransport._BaseFindSalesPartnerManagedClients, + MarketingplatformAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "MarketingplatformAdminServiceRestTransport.FindSalesPartnerManagedClients" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: marketingplatform_admin.FindSalesPartnerManagedClientsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.FindSalesPartnerManagedClientsResponse: + r"""Call the find sales partner + managed clients method over HTTP. + + Args: + request (~.marketingplatform_admin.FindSalesPartnerManagedClientsRequest): + The request object. Request message for + FindSalesPartnerManagedClients RPC. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.marketingplatform_admin.FindSalesPartnerManagedClientsResponse: + Response message for + FindSalesPartnerManagedClients RPC. + + """ + + http_options = ( + _BaseMarketingplatformAdminServiceRestTransport._BaseFindSalesPartnerManagedClients._get_http_options() + ) + + ( + request, + metadata, + ) = self._interceptor.pre_find_sales_partner_managed_clients( + request, metadata + ) + transcoded_request = _BaseMarketingplatformAdminServiceRestTransport._BaseFindSalesPartnerManagedClients._get_transcoded_request( + http_options, request + ) + + body = _BaseMarketingplatformAdminServiceRestTransport._BaseFindSalesPartnerManagedClients._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseMarketingplatformAdminServiceRestTransport._BaseFindSalesPartnerManagedClients._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.marketingplatform.admin_v1alpha.MarketingplatformAdminServiceClient.FindSalesPartnerManagedClients", + extra={ + "serviceName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "rpcName": "FindSalesPartnerManagedClients", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MarketingplatformAdminServiceRestTransport._FindSalesPartnerManagedClients._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # 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 = marketingplatform_admin.FindSalesPartnerManagedClientsResponse() + pb_resp = marketingplatform_admin.FindSalesPartnerManagedClientsResponse.pb( + resp + ) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_find_sales_partner_managed_clients(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_find_sales_partner_managed_clients_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = marketingplatform_admin.FindSalesPartnerManagedClientsResponse.to_json( + response + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.marketingplatform.admin_v1alpha.MarketingplatformAdminServiceClient.find_sales_partner_managed_clients", + extra={ + "serviceName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "rpcName": "FindSalesPartnerManagedClients", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + class _GetOrganization( _BaseMarketingplatformAdminServiceRestTransport._BaseGetOrganization, MarketingplatformAdminServiceRestStub, @@ -1010,13 +1359,329 @@ def __call__( ) return resp - class _SetPropertyServiceLevel( - _BaseMarketingplatformAdminServiceRestTransport._BaseSetPropertyServiceLevel, + class _ListOrganizations( + _BaseMarketingplatformAdminServiceRestTransport._BaseListOrganizations, MarketingplatformAdminServiceRestStub, ): def __hash__(self): - return hash( - "MarketingplatformAdminServiceRestTransport.SetPropertyServiceLevel" + return hash("MarketingplatformAdminServiceRestTransport.ListOrganizations") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: marketingplatform_admin.ListOrganizationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.ListOrganizationsResponse: + r"""Call the list organizations method over HTTP. + + Args: + request (~.marketingplatform_admin.ListOrganizationsRequest): + The request object. Request message for ListOrganizations + RPC. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.marketingplatform_admin.ListOrganizationsResponse: + Response message for + ListOrganizations RPC. + + """ + + http_options = ( + _BaseMarketingplatformAdminServiceRestTransport._BaseListOrganizations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_organizations( + request, metadata + ) + transcoded_request = _BaseMarketingplatformAdminServiceRestTransport._BaseListOrganizations._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMarketingplatformAdminServiceRestTransport._BaseListOrganizations._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.marketingplatform.admin_v1alpha.MarketingplatformAdminServiceClient.ListOrganizations", + extra={ + "serviceName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "rpcName": "ListOrganizations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MarketingplatformAdminServiceRestTransport._ListOrganizations._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = marketingplatform_admin.ListOrganizationsResponse() + pb_resp = marketingplatform_admin.ListOrganizationsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_organizations(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_list_organizations_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + marketingplatform_admin.ListOrganizationsResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.marketingplatform.admin_v1alpha.MarketingplatformAdminServiceClient.list_organizations", + extra={ + "serviceName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "rpcName": "ListOrganizations", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ReportPropertyUsage( + _BaseMarketingplatformAdminServiceRestTransport._BaseReportPropertyUsage, + MarketingplatformAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "MarketingplatformAdminServiceRestTransport.ReportPropertyUsage" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: marketingplatform_admin.ReportPropertyUsageRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> marketingplatform_admin.ReportPropertyUsageResponse: + r"""Call the report property usage method over HTTP. + + Args: + request (~.marketingplatform_admin.ReportPropertyUsageRequest): + The request object. Request message for + ReportPropertyUsage RPC. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.marketingplatform_admin.ReportPropertyUsageResponse: + Response message for + ReportPropertyUsage RPC. + + """ + + http_options = ( + _BaseMarketingplatformAdminServiceRestTransport._BaseReportPropertyUsage._get_http_options() + ) + + request, metadata = self._interceptor.pre_report_property_usage( + request, metadata + ) + transcoded_request = _BaseMarketingplatformAdminServiceRestTransport._BaseReportPropertyUsage._get_transcoded_request( + http_options, request + ) + + body = _BaseMarketingplatformAdminServiceRestTransport._BaseReportPropertyUsage._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseMarketingplatformAdminServiceRestTransport._BaseReportPropertyUsage._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.marketingplatform.admin_v1alpha.MarketingplatformAdminServiceClient.ReportPropertyUsage", + extra={ + "serviceName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "rpcName": "ReportPropertyUsage", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MarketingplatformAdminServiceRestTransport._ReportPropertyUsage._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # 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 = marketingplatform_admin.ReportPropertyUsageResponse() + pb_resp = marketingplatform_admin.ReportPropertyUsageResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_report_property_usage(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_report_property_usage_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + marketingplatform_admin.ReportPropertyUsageResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.marketingplatform.admin_v1alpha.MarketingplatformAdminServiceClient.report_property_usage", + extra={ + "serviceName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "rpcName": "ReportPropertyUsage", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _SetPropertyServiceLevel( + _BaseMarketingplatformAdminServiceRestTransport._BaseSetPropertyServiceLevel, + MarketingplatformAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "MarketingplatformAdminServiceRestTransport.SetPropertyServiceLevel" ) @staticmethod @@ -1194,6 +1859,17 @@ def delete_analytics_account_link( # In C++ this would require a dynamic_cast return self._DeleteAnalyticsAccountLink(self._session, self._host, self._interceptor) # type: ignore + @property + def find_sales_partner_managed_clients( + self, + ) -> Callable[ + [marketingplatform_admin.FindSalesPartnerManagedClientsRequest], + marketingplatform_admin.FindSalesPartnerManagedClientsResponse, + ]: + # 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._FindSalesPartnerManagedClients(self._session, self._host, self._interceptor) # type: ignore + @property def get_organization( self, @@ -1215,6 +1891,28 @@ def list_analytics_account_links( # In C++ this would require a dynamic_cast return self._ListAnalyticsAccountLinks(self._session, self._host, self._interceptor) # type: ignore + @property + def list_organizations( + self, + ) -> Callable[ + [marketingplatform_admin.ListOrganizationsRequest], + marketingplatform_admin.ListOrganizationsResponse, + ]: + # 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._ListOrganizations(self._session, self._host, self._interceptor) # type: ignore + + @property + def report_property_usage( + self, + ) -> Callable[ + [marketingplatform_admin.ReportPropertyUsageRequest], + marketingplatform_admin.ReportPropertyUsageResponse, + ]: + # 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._ReportPropertyUsage(self._session, self._host, self._interceptor) # type: ignore + @property def set_property_service_level( self, diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest_base.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest_base.py index fd985ea5637d..07c7078500af 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest_base.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/services/marketingplatform_admin_service/transports/rest_base.py @@ -201,6 +201,67 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseFindSalesPartnerManagedClients: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1alpha/{organization=organizations/*}:findSalesPartnerManagedClients", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = ( + marketingplatform_admin.FindSalesPartnerManagedClientsRequest.pb( + request + ) + ) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], use_integers_for_enums=True + ) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMarketingplatformAdminServiceRestTransport._BaseFindSalesPartnerManagedClients._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseGetOrganization: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -297,6 +358,95 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseListOrganizations: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1alpha/organizations", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = marketingplatform_admin.ListOrganizationsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseReportPropertyUsage: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1alpha/{organization=organizations/*}:reportPropertyUsage", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = marketingplatform_admin.ReportPropertyUsageRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], use_integers_for_enums=True + ) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMarketingplatformAdminServiceRestTransport._BaseReportPropertyUsage._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseSetPropertyServiceLevel: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/__init__.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/__init__.py index 7404673eb608..5c08f7971e39 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/__init__.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/__init__.py @@ -14,27 +14,45 @@ # limitations under the License. # from .marketingplatform_admin import ( - AnalyticsServiceLevel, CreateAnalyticsAccountLinkRequest, DeleteAnalyticsAccountLinkRequest, + FindSalesPartnerManagedClientsRequest, + FindSalesPartnerManagedClientsResponse, GetOrganizationRequest, ListAnalyticsAccountLinksRequest, ListAnalyticsAccountLinksResponse, + ListOrganizationsRequest, + ListOrganizationsResponse, + ReportPropertyUsageRequest, + ReportPropertyUsageResponse, SetPropertyServiceLevelRequest, SetPropertyServiceLevelResponse, ) -from .resources import AnalyticsAccountLink, LinkVerificationState, Organization +from .resources import ( + AnalyticsAccountLink, + AnalyticsPropertyType, + AnalyticsServiceLevel, + LinkVerificationState, + Organization, +) __all__ = ( "CreateAnalyticsAccountLinkRequest", "DeleteAnalyticsAccountLinkRequest", + "FindSalesPartnerManagedClientsRequest", + "FindSalesPartnerManagedClientsResponse", "GetOrganizationRequest", "ListAnalyticsAccountLinksRequest", "ListAnalyticsAccountLinksResponse", + "ListOrganizationsRequest", + "ListOrganizationsResponse", + "ReportPropertyUsageRequest", + "ReportPropertyUsageResponse", "SetPropertyServiceLevelRequest", "SetPropertyServiceLevelResponse", - "AnalyticsServiceLevel", "AnalyticsAccountLink", "Organization", + "AnalyticsPropertyType", + "AnalyticsServiceLevel", "LinkVerificationState", ) diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/marketingplatform_admin.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/marketingplatform_admin.py index b704eb3ae105..ed54d076b297 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/marketingplatform_admin.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/marketingplatform_admin.py @@ -17,6 +17,8 @@ from typing import MutableMapping, MutableSequence +from google.type import date_pb2 # type: ignore +from google.type import money_pb2 # type: ignore import proto # type: ignore from google.ads.marketingplatform_admin_v1alpha.types import resources @@ -24,34 +26,23 @@ __protobuf__ = proto.module( package="google.marketingplatform.admin.v1alpha", manifest={ - "AnalyticsServiceLevel", "GetOrganizationRequest", + "ListOrganizationsRequest", + "ListOrganizationsResponse", + "FindSalesPartnerManagedClientsRequest", + "FindSalesPartnerManagedClientsResponse", "ListAnalyticsAccountLinksRequest", "ListAnalyticsAccountLinksResponse", "CreateAnalyticsAccountLinkRequest", "DeleteAnalyticsAccountLinkRequest", "SetPropertyServiceLevelRequest", "SetPropertyServiceLevelResponse", + "ReportPropertyUsageRequest", + "ReportPropertyUsageResponse", }, ) -class AnalyticsServiceLevel(proto.Enum): - r"""Various levels of service for Google Analytics. - - Values: - ANALYTICS_SERVICE_LEVEL_UNSPECIFIED (0): - Service level unspecified. - ANALYTICS_SERVICE_LEVEL_STANDARD (1): - The standard version of Google Analytics. - ANALYTICS_SERVICE_LEVEL_360 (2): - The premium version of Google Analytics. - """ - ANALYTICS_SERVICE_LEVEL_UNSPECIFIED = 0 - ANALYTICS_SERVICE_LEVEL_STANDARD = 1 - ANALYTICS_SERVICE_LEVEL_360 = 2 - - class GetOrganizationRequest(proto.Message): r"""Request message for GetOrganization RPC. @@ -67,6 +58,135 @@ class GetOrganizationRequest(proto.Message): ) +class ListOrganizationsRequest(proto.Message): + r"""Request message for ListOrganizations RPC. + + Attributes: + page_size (int): + Optional. The maximum number of organizations + to return in one call. The service may return + fewer than this value. + + If unspecified, at most 50 organizations will be + returned. The maximum value is 1000; values + above 1000 will be coerced to 1000. + page_token (str): + Optional. A page token, received from a previous + ListOrganizations call. Provide this to retrieve the + subsequent page. + + When paginating, all other parameters provided to + ``ListOrganizations`` must match the call that provided the + page token. + """ + + page_size: int = proto.Field( + proto.INT32, + number=1, + ) + page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class ListOrganizationsResponse(proto.Message): + r"""Response message for ListOrganizations RPC. + + Attributes: + organizations (MutableSequence[google.ads.marketingplatform_admin_v1alpha.types.Organization]): + The Organization resource that the user has + access to, which includes the org id and display + name. + 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 + + organizations: MutableSequence[resources.Organization] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=resources.Organization, + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class FindSalesPartnerManagedClientsRequest(proto.Message): + r"""Request message for FindSalesPartnerManagedClients RPC. + + Attributes: + organization (str): + Required. The name of the sales partner organization. + Format: organizations/{org_id} + is_active (bool): + Optional. If set, only active and just ended + clients will be returned. + """ + + organization: str = proto.Field( + proto.STRING, + number=1, + ) + is_active: bool = proto.Field( + proto.BOOL, + number=2, + ) + + +class FindSalesPartnerManagedClientsResponse(proto.Message): + r"""Response message for FindSalesPartnerManagedClients RPC. + + Attributes: + client_data (MutableSequence[google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsResponse.ClientData]): + The clients managed by the sales org. + """ + + class ClientData(proto.Message): + r"""Contains the client data. + + Attributes: + organization (google.ads.marketingplatform_admin_v1alpha.types.Organization): + The end client that has/had contract with the + requested sales org. + start_date (google.type.date_pb2.Date): + The start date of the contract between the + sales org and the end client. + end_date (google.type.date_pb2.Date): + The end date of the contract between the + sales org and the end client. + """ + + organization: resources.Organization = proto.Field( + proto.MESSAGE, + number=1, + message=resources.Organization, + ) + start_date: date_pb2.Date = proto.Field( + proto.MESSAGE, + number=2, + message=date_pb2.Date, + ) + end_date: date_pb2.Date = proto.Field( + proto.MESSAGE, + number=3, + message=date_pb2.Date, + ) + + client_data: MutableSequence[ClientData] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=ClientData, + ) + + class ListAnalyticsAccountLinksRequest(proto.Message): r"""Request message for ListAnalyticsAccountLinks RPC. @@ -203,10 +323,10 @@ class SetPropertyServiceLevelRequest(proto.Message): proto.STRING, number=2, ) - service_level: "AnalyticsServiceLevel" = proto.Field( + service_level: resources.AnalyticsServiceLevel = proto.Field( proto.ENUM, number=3, - enum="AnalyticsServiceLevel", + enum=resources.AnalyticsServiceLevel, ) @@ -214,4 +334,150 @@ class SetPropertyServiceLevelResponse(proto.Message): r"""Response message for SetPropertyServiceLevel RPC.""" +class ReportPropertyUsageRequest(proto.Message): + r"""Request message for ReportPropertyUsage RPC. + + Attributes: + organization (str): + Required. Specifies the organization whose property usage + will be listed. + + Format: organizations/{org_id} + month (str): + Required. The target month to list property + usages. + Format: YYYY-MM. For example, "2025-05". + """ + + organization: str = proto.Field( + proto.STRING, + number=1, + ) + month: str = proto.Field( + proto.STRING, + number=2, + ) + + +class ReportPropertyUsageResponse(proto.Message): + r"""Response message for ReportPropertyUsage RPC. + + Attributes: + property_usages (MutableSequence[google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageResponse.PropertyUsage]): + Usage data for all properties in the + specified organization and month. + bill_info (google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageResponse.BillInfo): + Bill amount in the specified organization and + month. + Will be empty if user only has access to usage + data. + """ + + class PropertyUsage(proto.Message): + r"""Contains the count of events received by the property, along with + metadata that influences the volume of ``billable`` events. + + Attributes: + property (str): + The name of the Google Analytics Admin API property + resource. + + Format: + analyticsadmin.googleapis.com/properties/{property_id} + display_name (str): + The display name of the property. + account_id (int): + The ID of the property's parent account. + service_level (google.ads.marketingplatform_admin_v1alpha.types.AnalyticsServiceLevel): + The service level of the property. + property_type (google.ads.marketingplatform_admin_v1alpha.types.AnalyticsPropertyType): + The subtype of the analytics property. This + affects the billable event count. + total_event_count (int): + Total event count that the property received + during the requested month. + billable_event_count (int): + The number of events for which the property + is billed in the requested month. + """ + + property: str = proto.Field( + proto.STRING, + number=1, + ) + display_name: str = proto.Field( + proto.STRING, + number=2, + ) + account_id: int = proto.Field( + proto.INT64, + number=3, + ) + service_level: resources.AnalyticsServiceLevel = proto.Field( + proto.ENUM, + number=4, + enum=resources.AnalyticsServiceLevel, + ) + property_type: resources.AnalyticsPropertyType = proto.Field( + proto.ENUM, + number=5, + enum=resources.AnalyticsPropertyType, + ) + total_event_count: int = proto.Field( + proto.INT64, + number=6, + ) + billable_event_count: int = proto.Field( + proto.INT64, + number=7, + ) + + class BillInfo(proto.Message): + r"""Contains the bill amount. + + Attributes: + base_fee (google.type.money_pb2.Money): + The amount of the monthly base fee. + event_fee (google.type.money_pb2.Money): + The amount of the event fee. + price_protection_credit (google.type.money_pb2.Money): + The amount of the price protection credit, + this is only available for eligible customers. + total (google.type.money_pb2.Money): + The total amount of the bill. + """ + + base_fee: money_pb2.Money = proto.Field( + proto.MESSAGE, + number=1, + message=money_pb2.Money, + ) + event_fee: money_pb2.Money = proto.Field( + proto.MESSAGE, + number=2, + message=money_pb2.Money, + ) + price_protection_credit: money_pb2.Money = proto.Field( + proto.MESSAGE, + number=3, + message=money_pb2.Money, + ) + total: money_pb2.Money = proto.Field( + proto.MESSAGE, + number=4, + message=money_pb2.Money, + ) + + property_usages: MutableSequence[PropertyUsage] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=PropertyUsage, + ) + bill_info: BillInfo = proto.Field( + proto.MESSAGE, + number=2, + message=BillInfo, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/resources.py b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/resources.py index 3273e02667e0..4dab191fa07d 100644 --- a/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/resources.py +++ b/packages/google-ads-marketingplatform-admin/google/ads/marketingplatform_admin_v1alpha/types/resources.py @@ -23,6 +23,8 @@ package="google.marketingplatform.admin.v1alpha", manifest={ "LinkVerificationState", + "AnalyticsServiceLevel", + "AnalyticsPropertyType", "Organization", "AnalyticsAccountLink", }, @@ -47,6 +49,41 @@ class LinkVerificationState(proto.Enum): LINK_VERIFICATION_STATE_NOT_VERIFIED = 2 +class AnalyticsServiceLevel(proto.Enum): + r"""Various levels of service for Google Analytics. + + Values: + ANALYTICS_SERVICE_LEVEL_UNSPECIFIED (0): + Service level unspecified. + ANALYTICS_SERVICE_LEVEL_STANDARD (1): + The standard version of Google Analytics. + ANALYTICS_SERVICE_LEVEL_360 (2): + The premium version of Google Analytics. + """ + ANALYTICS_SERVICE_LEVEL_UNSPECIFIED = 0 + ANALYTICS_SERVICE_LEVEL_STANDARD = 1 + ANALYTICS_SERVICE_LEVEL_360 = 2 + + +class AnalyticsPropertyType(proto.Enum): + r"""Types of the Google Analytics Property. + + Values: + ANALYTICS_PROPERTY_TYPE_UNSPECIFIED (0): + Unknown or unspecified property type + ANALYTICS_PROPERTY_TYPE_ORDINARY (1): + Ordinary Google Analytics property + ANALYTICS_PROPERTY_TYPE_SUBPROPERTY (2): + Google Analytics subproperty + ANALYTICS_PROPERTY_TYPE_ROLLUP (3): + Google Analytics rollup property + """ + ANALYTICS_PROPERTY_TYPE_UNSPECIFIED = 0 + ANALYTICS_PROPERTY_TYPE_ORDINARY = 1 + ANALYTICS_PROPERTY_TYPE_SUBPROPERTY = 2 + ANALYTICS_PROPERTY_TYPE_ROLLUP = 3 + + class Organization(proto.Message): r"""A resource message representing a Google Marketing Platform organization. diff --git a/packages/google-ads-marketingplatform-admin/noxfile.py b/packages/google-ads-marketingplatform-admin/noxfile.py index 44c7f351a55e..0a8f35d7b244 100644 --- a/packages/google-ads-marketingplatform-admin/noxfile.py +++ b/packages/google-ads-marketingplatform-admin/noxfile.py @@ -27,6 +27,10 @@ LINT_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"] +# Add samples to the list of directories to format if the directory exists. +if os.path.isdir("samples"): + LINT_PATHS.append("samples") + ALL_PYTHON = [ "3.7", "3.8", diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_async.py index 9ce0c18b807d..cd6c6687119c 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_async.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_async.py @@ -53,4 +53,5 @@ async def sample_create_analytics_account_link(): # Handle the response print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_CreateAnalyticsAccountLink_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_sync.py index 6647383a9d8f..14bc721204c5 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_sync.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_create_analytics_account_link_sync.py @@ -53,4 +53,5 @@ def sample_create_analytics_account_link(): # Handle the response print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_CreateAnalyticsAccountLink_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_async.py new file mode 100644 index 000000000000..e799ca7d1181 --- /dev/null +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 FindSalesPartnerManagedClients +# 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-ads-marketingplatform-admin + + +# [START marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_FindSalesPartnerManagedClients_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.ads import marketingplatform_admin_v1alpha + + +async def sample_find_sales_partner_managed_clients(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.FindSalesPartnerManagedClientsRequest( + organization="organization_value", + ) + + # Make the request + response = await client.find_sales_partner_managed_clients(request=request) + + # Handle the response + print(response) + + +# [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_FindSalesPartnerManagedClients_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_sync.py new file mode 100644 index 000000000000..06c74d57b9cb --- /dev/null +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 FindSalesPartnerManagedClients +# 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-ads-marketingplatform-admin + + +# [START marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_FindSalesPartnerManagedClients_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.ads import marketingplatform_admin_v1alpha + + +def sample_find_sales_partner_managed_clients(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.FindSalesPartnerManagedClientsRequest( + organization="organization_value", + ) + + # Make the request + response = client.find_sales_partner_managed_clients(request=request) + + # Handle the response + print(response) + + +# [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_FindSalesPartnerManagedClients_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_async.py index d439e74fb019..cbda174ca5c1 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_async.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_async.py @@ -49,4 +49,5 @@ async def sample_get_organization(): # Handle the response print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_GetOrganization_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_sync.py index 3f5013acb546..70c86b4c8363 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_sync.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_get_organization_sync.py @@ -49,4 +49,5 @@ def sample_get_organization(): # Handle the response print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_GetOrganization_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_async.py index 6d8fa1e81cf2..1444b9fad0ee 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_async.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_async.py @@ -50,4 +50,5 @@ async def sample_list_analytics_account_links(): async for response in page_result: print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListAnalyticsAccountLinks_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_sync.py index 21635e24ea46..b784557e8153 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_sync.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_sync.py @@ -50,4 +50,5 @@ def sample_list_analytics_account_links(): for response in page_result: print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListAnalyticsAccountLinks_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_async.py new file mode 100644 index 000000000000..577d7eee8422 --- /dev/null +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_async.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListOrganizations +# 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-ads-marketingplatform-admin + + +# [START marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListOrganizations_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.ads import marketingplatform_admin_v1alpha + + +async def sample_list_organizations(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ListOrganizationsRequest() + + # Make the request + page_result = client.list_organizations(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListOrganizations_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_sync.py new file mode 100644 index 000000000000..9084b1d75c4e --- /dev/null +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_sync.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListOrganizations +# 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-ads-marketingplatform-admin + + +# [START marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListOrganizations_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.ads import marketingplatform_admin_v1alpha + + +def sample_list_organizations(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ListOrganizationsRequest() + + # Make the request + page_result = client.list_organizations(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListOrganizations_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_async.py new file mode 100644 index 000000000000..e19a56866e58 --- /dev/null +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ReportPropertyUsage +# 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-ads-marketingplatform-admin + + +# [START marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ReportPropertyUsage_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.ads import marketingplatform_admin_v1alpha + + +async def sample_report_property_usage(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ReportPropertyUsageRequest( + organization="organization_value", + month="month_value", + ) + + # Make the request + response = await client.report_property_usage(request=request) + + # Handle the response + print(response) + + +# [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ReportPropertyUsage_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_sync.py new file mode 100644 index 000000000000..c174bb012400 --- /dev/null +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ReportPropertyUsage +# 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-ads-marketingplatform-admin + + +# [START marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ReportPropertyUsage_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.ads import marketingplatform_admin_v1alpha + + +def sample_report_property_usage(): + # Create a client + client = marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient() + + # Initialize request argument(s) + request = marketingplatform_admin_v1alpha.ReportPropertyUsageRequest( + organization="organization_value", + month="month_value", + ) + + # Make the request + response = client.report_property_usage(request=request) + + # Handle the response + print(response) + + +# [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ReportPropertyUsage_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_async.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_async.py index 002b705efd82..8f7cf8f7e2d5 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_async.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_async.py @@ -51,4 +51,5 @@ async def sample_set_property_service_level(): # Handle the response print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_SetPropertyServiceLevel_async] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_sync.py b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_sync.py index 44a8436b3131..4fa92ff1430b 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_sync.py +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_set_property_service_level_sync.py @@ -51,4 +51,5 @@ def sample_set_property_service_level(): # Handle the response print(response) + # [END marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_SetPropertyServiceLevel_sync] diff --git a/packages/google-ads-marketingplatform-admin/samples/generated_samples/snippet_metadata_google.marketingplatform.admin.v1alpha.json b/packages/google-ads-marketingplatform-admin/samples/generated_samples/snippet_metadata_google.marketingplatform.admin.v1alpha.json index d8e38d21950d..443b2c434143 100644 --- a/packages/google-ads-marketingplatform-admin/samples/generated_samples/snippet_metadata_google.marketingplatform.admin.v1alpha.json +++ b/packages/google-ads-marketingplatform-admin/samples/generated_samples/snippet_metadata_google.marketingplatform.admin.v1alpha.json @@ -335,6 +335,159 @@ ], "title": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_delete_analytics_account_link_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient", + "shortName": "MarketingplatformAdminServiceAsyncClient" + }, + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient.find_sales_partner_managed_clients", + "method": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService.FindSalesPartnerManagedClients", + "service": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "shortName": "MarketingplatformAdminService" + }, + "shortName": "FindSalesPartnerManagedClients" + }, + "parameters": [ + { + "name": "request", + "type": "google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsResponse", + "shortName": "find_sales_partner_managed_clients" + }, + "description": "Sample for FindSalesPartnerManagedClients", + "file": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_FindSalesPartnerManagedClients_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient", + "shortName": "MarketingplatformAdminServiceClient" + }, + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient.find_sales_partner_managed_clients", + "method": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService.FindSalesPartnerManagedClients", + "service": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "shortName": "MarketingplatformAdminService" + }, + "shortName": "FindSalesPartnerManagedClients" + }, + "parameters": [ + { + "name": "request", + "type": "google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.ads.marketingplatform_admin_v1alpha.types.FindSalesPartnerManagedClientsResponse", + "shortName": "find_sales_partner_managed_clients" + }, + "description": "Sample for FindSalesPartnerManagedClients", + "file": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_FindSalesPartnerManagedClients_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_find_sales_partner_managed_clients_sync.py" + }, { "canonical": true, "clientMethod": { @@ -657,6 +810,320 @@ ], "title": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_analytics_account_links_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient", + "shortName": "MarketingplatformAdminServiceAsyncClient" + }, + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient.list_organizations", + "method": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService.ListOrganizations", + "service": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "shortName": "MarketingplatformAdminService" + }, + "shortName": "ListOrganizations" + }, + "parameters": [ + { + "name": "request", + "type": "google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.ads.marketingplatform_admin_v1alpha.services.marketingplatform_admin_service.pagers.ListOrganizationsAsyncPager", + "shortName": "list_organizations" + }, + "description": "Sample for ListOrganizations", + "file": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListOrganizations_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": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient", + "shortName": "MarketingplatformAdminServiceClient" + }, + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient.list_organizations", + "method": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService.ListOrganizations", + "service": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "shortName": "MarketingplatformAdminService" + }, + "shortName": "ListOrganizations" + }, + "parameters": [ + { + "name": "request", + "type": "google.ads.marketingplatform_admin_v1alpha.types.ListOrganizationsRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.ads.marketingplatform_admin_v1alpha.services.marketingplatform_admin_service.pagers.ListOrganizationsPager", + "shortName": "list_organizations" + }, + "description": "Sample for ListOrganizations", + "file": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ListOrganizations_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": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_list_organizations_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient", + "shortName": "MarketingplatformAdminServiceAsyncClient" + }, + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceAsyncClient.report_property_usage", + "method": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService.ReportPropertyUsage", + "service": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "shortName": "MarketingplatformAdminService" + }, + "shortName": "ReportPropertyUsage" + }, + "parameters": [ + { + "name": "request", + "type": "google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageRequest" + }, + { + "name": "organization", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageResponse", + "shortName": "report_property_usage" + }, + "description": "Sample for ReportPropertyUsage", + "file": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ReportPropertyUsage_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient", + "shortName": "MarketingplatformAdminServiceClient" + }, + "fullName": "google.ads.marketingplatform_admin_v1alpha.MarketingplatformAdminServiceClient.report_property_usage", + "method": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService.ReportPropertyUsage", + "service": { + "fullName": "google.marketingplatform.admin.v1alpha.MarketingplatformAdminService", + "shortName": "MarketingplatformAdminService" + }, + "shortName": "ReportPropertyUsage" + }, + "parameters": [ + { + "name": "request", + "type": "google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageRequest" + }, + { + "name": "organization", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.ads.marketingplatform_admin_v1alpha.types.ReportPropertyUsageResponse", + "shortName": "report_property_usage" + }, + "description": "Sample for ReportPropertyUsage", + "file": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "marketingplatformadmin_v1alpha_generated_MarketingplatformAdminService_ReportPropertyUsage_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "marketingplatformadmin_v1alpha_generated_marketingplatform_admin_service_report_property_usage_sync.py" + }, { "canonical": true, "clientMethod": { diff --git a/packages/google-ads-marketingplatform-admin/scripts/fixup_marketingplatform_admin_v1alpha_keywords.py b/packages/google-ads-marketingplatform-admin/scripts/fixup_marketingplatform_admin_v1alpha_keywords.py index 0820dcaf1b40..274512a5196f 100644 --- a/packages/google-ads-marketingplatform-admin/scripts/fixup_marketingplatform_admin_v1alpha_keywords.py +++ b/packages/google-ads-marketingplatform-admin/scripts/fixup_marketingplatform_admin_v1alpha_keywords.py @@ -41,8 +41,11 @@ class marketingplatform_adminCallTransformer(cst.CSTTransformer): METHOD_TO_PARAMS: Dict[str, Tuple[str]] = { 'create_analytics_account_link': ('parent', 'analytics_account_link', ), 'delete_analytics_account_link': ('name', ), + 'find_sales_partner_managed_clients': ('organization', 'is_active', ), 'get_organization': ('name', ), 'list_analytics_account_links': ('parent', 'page_size', 'page_token', ), + 'list_organizations': ('page_size', 'page_token', ), + 'report_property_usage': ('organization', 'month', ), 'set_property_service_level': ('analytics_account_link', 'analytics_property', 'service_level', ), } diff --git a/packages/google-ads-marketingplatform-admin/tests/unit/gapic/marketingplatform_admin_v1alpha/test_marketingplatform_admin_service.py b/packages/google-ads-marketingplatform-admin/tests/unit/gapic/marketingplatform_admin_v1alpha/test_marketingplatform_admin_service.py index 2fd000b5ac91..ad3d38f109ac 100644 --- a/packages/google-ads-marketingplatform-admin/tests/unit/gapic/marketingplatform_admin_v1alpha/test_marketingplatform_admin_service.py +++ b/packages/google-ads-marketingplatform-admin/tests/unit/gapic/marketingplatform_admin_v1alpha/test_marketingplatform_admin_service.py @@ -1535,11 +1535,11 @@ async def test_get_organization_flattened_error_async(): @pytest.mark.parametrize( "request_type", [ - marketingplatform_admin.ListAnalyticsAccountLinksRequest, + marketingplatform_admin.ListOrganizationsRequest, dict, ], ) -def test_list_analytics_account_links(request_type, transport: str = "grpc"): +def test_list_organizations(request_type, transport: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -1551,26 +1551,26 @@ def test_list_analytics_account_links(request_type, transport: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" + type(client.transport.list_organizations), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse( + call.return_value = marketingplatform_admin.ListOrganizationsResponse( next_page_token="next_page_token_value", ) - response = client.list_analytics_account_links(request) + response = client.list_organizations(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() + request = marketingplatform_admin.ListOrganizationsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAnalyticsAccountLinksPager) + assert isinstance(response, pagers.ListOrganizationsPager) assert response.next_page_token == "next_page_token_value" -def test_list_analytics_account_links_non_empty_request_with_auto_populated_field(): +def test_list_organizations_non_empty_request_with_auto_populated_field(): # This test is a coverage failsafe to make sure that UUID4 fields are # automatically populated, according to AIP-4235, with non-empty requests. client = MarketingplatformAdminServiceClient( @@ -1581,28 +1581,26 @@ def test_list_analytics_account_links_non_empty_request_with_auto_populated_fiel # Populate all string fields in the request which are not UUID4 # since we want to check that UUID4 are populated automatically # if they meet the requirements of AIP 4235. - request = marketingplatform_admin.ListAnalyticsAccountLinksRequest( - parent="parent_value", + request = marketingplatform_admin.ListOrganizationsRequest( page_token="page_token_value", ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" + type(client.transport.list_organizations), "__call__" ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.list_analytics_account_links(request=request) + client.list_organizations(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == marketingplatform_admin.ListAnalyticsAccountLinksRequest( - parent="parent_value", + assert args[0] == marketingplatform_admin.ListOrganizationsRequest( page_token="page_token_value", ) -def test_list_analytics_account_links_use_cached_wrapped_rpc(): +def test_list_organizations_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -1617,8 +1615,7 @@ def test_list_analytics_account_links_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_analytics_account_links - in client._transport._wrapped_methods + client._transport.list_organizations in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -1627,15 +1624,15 @@ def test_list_analytics_account_links_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_analytics_account_links + client._transport.list_organizations ] = mock_rpc request = {} - client.list_analytics_account_links(request) + client.list_organizations(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_analytics_account_links(request) + client.list_organizations(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -1643,7 +1640,7 @@ def test_list_analytics_account_links_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_list_analytics_account_links_async_use_cached_wrapped_rpc( +async def test_list_organizations_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -1660,7 +1657,7 @@ async def test_list_analytics_account_links_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.list_analytics_account_links + client._client._transport.list_organizations in client._client._transport._wrapped_methods ) @@ -1668,16 +1665,16 @@ async def test_list_analytics_account_links_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.list_analytics_account_links + client._client._transport.list_organizations ] = mock_rpc request = {} - await client.list_analytics_account_links(request) + await client.list_organizations(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.list_analytics_account_links(request) + await client.list_organizations(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -1685,9 +1682,9 @@ async def test_list_analytics_account_links_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_list_analytics_account_links_async( +async def test_list_organizations_async( transport: str = "grpc_asyncio", - request_type=marketingplatform_admin.ListAnalyticsAccountLinksRequest, + request_type=marketingplatform_admin.ListOrganizationsRequest, ): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), @@ -1700,184 +1697,33 @@ async def test_list_analytics_account_links_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" + type(client.transport.list_organizations), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - marketingplatform_admin.ListAnalyticsAccountLinksResponse( + marketingplatform_admin.ListOrganizationsResponse( next_page_token="next_page_token_value", ) ) - response = await client.list_analytics_account_links(request) + response = await client.list_organizations(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() + request = marketingplatform_admin.ListOrganizationsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAnalyticsAccountLinksAsyncPager) + assert isinstance(response, pagers.ListOrganizationsAsyncPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.asyncio -async def test_list_analytics_account_links_async_from_dict(): - await test_list_analytics_account_links_async(request_type=dict) - - -def test_list_analytics_account_links_field_headers(): - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - ) - - # Any value that is part of the HTTP/1.1 URI should be sent as - # a field header. Set these to a non-empty value. - request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() - - request.parent = "parent_value" - - # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" - ) as call: - call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse() - client.list_analytics_account_links(request) - - # Establish that the underlying gRPC stub method was called. - assert len(call.mock_calls) == 1 - _, args, _ = call.mock_calls[0] - assert args[0] == request - - # Establish that the field header was sent. - _, _, kw = call.mock_calls[0] - assert ( - "x-goog-request-params", - "parent=parent_value", - ) in kw["metadata"] - - -@pytest.mark.asyncio -async def test_list_analytics_account_links_field_headers_async(): - client = MarketingplatformAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - ) - - # Any value that is part of the HTTP/1.1 URI should be sent as - # a field header. Set these to a non-empty value. - request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() - - request.parent = "parent_value" - - # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" - ) as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - marketingplatform_admin.ListAnalyticsAccountLinksResponse() - ) - await client.list_analytics_account_links(request) - - # Establish that the underlying gRPC stub method was called. - assert len(call.mock_calls) - _, args, _ = call.mock_calls[0] - assert args[0] == request - - # Establish that the field header was sent. - _, _, kw = call.mock_calls[0] - assert ( - "x-goog-request-params", - "parent=parent_value", - ) in kw["metadata"] - - -def test_list_analytics_account_links_flattened(): - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - ) - - # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse() - # Call the method with a truthy value for each flattened field, - # using the keyword arguments to the method. - client.list_analytics_account_links( - parent="parent_value", - ) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(call.mock_calls) == 1 - _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" - assert arg == mock_val - - -def test_list_analytics_account_links_flattened_error(): - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.list_analytics_account_links( - marketingplatform_admin.ListAnalyticsAccountLinksRequest(), - parent="parent_value", - ) - - -@pytest.mark.asyncio -async def test_list_analytics_account_links_flattened_async(): - client = MarketingplatformAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - ) - - # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse() - - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - marketingplatform_admin.ListAnalyticsAccountLinksResponse() - ) - # Call the method with a truthy value for each flattened field, - # using the keyword arguments to the method. - response = await client.list_analytics_account_links( - parent="parent_value", - ) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(call.mock_calls) - _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" - assert arg == mock_val - - -@pytest.mark.asyncio -async def test_list_analytics_account_links_flattened_error_async(): - client = MarketingplatformAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - await client.list_analytics_account_links( - marketingplatform_admin.ListAnalyticsAccountLinksRequest(), - parent="parent_value", - ) +async def test_list_organizations_async_from_dict(): + await test_list_organizations_async(request_type=dict) -def test_list_analytics_account_links_pager(transport_name: str = "grpc"): +def test_list_organizations_pager(transport_name: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport_name, @@ -1885,32 +1731,32 @@ def test_list_analytics_account_links_pager(transport_name: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" + type(client.transport.list_organizations), "__call__" ) as call: # Set the response to a series of pages. call.side_effect = ( - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), + resources.Organization(), ], next_page_token="abc", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[], + marketingplatform_admin.ListOrganizationsResponse( + organizations=[], next_page_token="def", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), ], next_page_token="ghi", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), ], ), RuntimeError, @@ -1919,12 +1765,7 @@ def test_list_analytics_account_links_pager(transport_name: str = "grpc"): expected_metadata = () retry = retries.Retry() timeout = 5 - expected_metadata = tuple(expected_metadata) + ( - gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), - ) - pager = client.list_analytics_account_links( - request={}, retry=retry, timeout=timeout - ) + pager = client.list_organizations(request={}, retry=retry, timeout=timeout) assert pager._metadata == expected_metadata assert pager._retry == retry @@ -1932,10 +1773,10 @@ def test_list_analytics_account_links_pager(transport_name: str = "grpc"): results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.AnalyticsAccountLink) for i in results) + assert all(isinstance(i, resources.Organization) for i in results) -def test_list_analytics_account_links_pages(transport_name: str = "grpc"): +def test_list_organizations_pages(transport_name: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport_name, @@ -1943,82 +1784,82 @@ def test_list_analytics_account_links_pages(transport_name: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), "__call__" + type(client.transport.list_organizations), "__call__" ) as call: # Set the response to a series of pages. call.side_effect = ( - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), + resources.Organization(), ], next_page_token="abc", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[], + marketingplatform_admin.ListOrganizationsResponse( + organizations=[], next_page_token="def", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), ], next_page_token="ghi", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), ], ), RuntimeError, ) - pages = list(client.list_analytics_account_links(request={}).pages) + pages = list(client.list_organizations(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_analytics_account_links_async_pager(): +async def test_list_organizations_async_pager(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), + type(client.transport.list_organizations), "__call__", new_callable=mock.AsyncMock, ) as call: # Set the response to a series of pages. call.side_effect = ( - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), + resources.Organization(), ], next_page_token="abc", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[], + marketingplatform_admin.ListOrganizationsResponse( + organizations=[], next_page_token="def", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), ], next_page_token="ghi", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), ], ), RuntimeError, ) - async_pager = await client.list_analytics_account_links( + async_pager = await client.list_organizations( request={}, ) assert async_pager.next_page_token == "abc" @@ -2027,45 +1868,45 @@ async def test_list_analytics_account_links_async_pager(): responses.append(response) assert len(responses) == 6 - assert all(isinstance(i, resources.AnalyticsAccountLink) for i in responses) + assert all(isinstance(i, resources.Organization) for i in responses) @pytest.mark.asyncio -async def test_list_analytics_account_links_async_pages(): +async def test_list_organizations_async_pages(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_analytics_account_links), + type(client.transport.list_organizations), "__call__", new_callable=mock.AsyncMock, ) as call: # Set the response to a series of pages. call.side_effect = ( - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), + resources.Organization(), ], next_page_token="abc", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[], + marketingplatform_admin.ListOrganizationsResponse( + organizations=[], next_page_token="def", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), ], next_page_token="ghi", ), - marketingplatform_admin.ListAnalyticsAccountLinksResponse( - analytics_account_links=[ - resources.AnalyticsAccountLink(), - resources.AnalyticsAccountLink(), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), ], ), RuntimeError, @@ -2074,7 +1915,7 @@ async def test_list_analytics_account_links_async_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_analytics_account_links(request={}) + await client.list_organizations(request={}) ).pages: pages.append(page_) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): @@ -2084,11 +1925,11 @@ async def test_list_analytics_account_links_async_pages(): @pytest.mark.parametrize( "request_type", [ - marketingplatform_admin.CreateAnalyticsAccountLinkRequest, + marketingplatform_admin.FindSalesPartnerManagedClientsRequest, dict, ], ) -def test_create_analytics_account_link(request_type, transport: str = "grpc"): +def test_find_sales_partner_managed_clients(request_type, transport: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -2100,35 +1941,27 @@ def test_create_analytics_account_link(request_type, transport: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" + type(client.transport.find_sales_partner_managed_clients), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = resources.AnalyticsAccountLink( - name="name_value", - analytics_account="analytics_account_value", - display_name="display_name_value", - link_verification_state=resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED, + call.return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() ) - response = client.create_analytics_account_link(request) + response = client.find_sales_partner_managed_clients(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, resources.AnalyticsAccountLink) - assert response.name == "name_value" - assert response.analytics_account == "analytics_account_value" - assert response.display_name == "display_name_value" - assert ( - response.link_verification_state - == resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED + assert isinstance( + response, marketingplatform_admin.FindSalesPartnerManagedClientsResponse ) -def test_create_analytics_account_link_non_empty_request_with_auto_populated_field(): +def test_find_sales_partner_managed_clients_non_empty_request_with_auto_populated_field(): # This test is a coverage failsafe to make sure that UUID4 fields are # automatically populated, according to AIP-4235, with non-empty requests. client = MarketingplatformAdminServiceClient( @@ -2139,26 +1972,26 @@ def test_create_analytics_account_link_non_empty_request_with_auto_populated_fie # Populate all string fields in the request which are not UUID4 # since we want to check that UUID4 are populated automatically # if they meet the requirements of AIP 4235. - request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest( - parent="parent_value", + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest( + organization="organization_value", ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" + type(client.transport.find_sales_partner_managed_clients), "__call__" ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.create_analytics_account_link(request=request) + client.find_sales_partner_managed_clients(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == marketingplatform_admin.CreateAnalyticsAccountLinkRequest( - parent="parent_value", + assert args[0] == marketingplatform_admin.FindSalesPartnerManagedClientsRequest( + organization="organization_value", ) -def test_create_analytics_account_link_use_cached_wrapped_rpc(): +def test_find_sales_partner_managed_clients_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -2173,7 +2006,7 @@ def test_create_analytics_account_link_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_analytics_account_link + client._transport.find_sales_partner_managed_clients in client._transport._wrapped_methods ) @@ -2183,15 +2016,15 @@ def test_create_analytics_account_link_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_analytics_account_link + client._transport.find_sales_partner_managed_clients ] = mock_rpc request = {} - client.create_analytics_account_link(request) + client.find_sales_partner_managed_clients(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_analytics_account_link(request) + client.find_sales_partner_managed_clients(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -2199,7 +2032,7 @@ def test_create_analytics_account_link_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_create_analytics_account_link_async_use_cached_wrapped_rpc( +async def test_find_sales_partner_managed_clients_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -2216,7 +2049,7 @@ async def test_create_analytics_account_link_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.create_analytics_account_link + client._client._transport.find_sales_partner_managed_clients in client._client._transport._wrapped_methods ) @@ -2224,16 +2057,16 @@ async def test_create_analytics_account_link_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.create_analytics_account_link + client._client._transport.find_sales_partner_managed_clients ] = mock_rpc request = {} - await client.create_analytics_account_link(request) + await client.find_sales_partner_managed_clients(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.create_analytics_account_link(request) + await client.find_sales_partner_managed_clients(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -2241,9 +2074,9 @@ async def test_create_analytics_account_link_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_create_analytics_account_link_async( +async def test_find_sales_partner_managed_clients_async( transport: str = "grpc_asyncio", - request_type=marketingplatform_admin.CreateAnalyticsAccountLinkRequest, + request_type=marketingplatform_admin.FindSalesPartnerManagedClientsRequest, ): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), @@ -2256,58 +2089,50 @@ async def test_create_analytics_account_link_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" + type(client.transport.find_sales_partner_managed_clients), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AnalyticsAccountLink( - name="name_value", - analytics_account="analytics_account_value", - display_name="display_name_value", - link_verification_state=resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED, - ) + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() ) - response = await client.create_analytics_account_link(request) + response = await client.find_sales_partner_managed_clients(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, resources.AnalyticsAccountLink) - assert response.name == "name_value" - assert response.analytics_account == "analytics_account_value" - assert response.display_name == "display_name_value" - assert ( - response.link_verification_state - == resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED + assert isinstance( + response, marketingplatform_admin.FindSalesPartnerManagedClientsResponse ) @pytest.mark.asyncio -async def test_create_analytics_account_link_async_from_dict(): - await test_create_analytics_account_link_async(request_type=dict) +async def test_find_sales_partner_managed_clients_async_from_dict(): + await test_find_sales_partner_managed_clients_async(request_type=dict) -def test_create_analytics_account_link_field_headers(): +def test_find_sales_partner_managed_clients_field_headers(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) # Any value that is part of the HTTP/1.1 URI should be sent as # a field header. Set these to a non-empty value. - request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() - request.parent = "parent_value" + request.organization = "organization_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" + type(client.transport.find_sales_partner_managed_clients), "__call__" ) as call: - call.return_value = resources.AnalyticsAccountLink() - client.create_analytics_account_link(request) + call.return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() + ) + client.find_sales_partner_managed_clients(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -2318,30 +2143,30 @@ def test_create_analytics_account_link_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "organization=organization_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_create_analytics_account_link_field_headers_async(): +async def test_find_sales_partner_managed_clients_field_headers_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Any value that is part of the HTTP/1.1 URI should be sent as # a field header. Set these to a non-empty value. - request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() - request.parent = "parent_value" + request.organization = "organization_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" + type(client.transport.find_sales_partner_managed_clients), "__call__" ) as call: call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AnalyticsAccountLink() + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() ) - await client.create_analytics_account_link(request) + await client.find_sales_partner_managed_clients(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -2352,114 +2177,18 @@ async def test_create_analytics_account_link_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "organization=organization_value", ) in kw["metadata"] -def test_create_analytics_account_link_flattened(): - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - ) - - # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = resources.AnalyticsAccountLink() - # Call the method with a truthy value for each flattened field, - # using the keyword arguments to the method. - client.create_analytics_account_link( - parent="parent_value", - analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), - ) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(call.mock_calls) == 1 - _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" - assert arg == mock_val - arg = args[0].analytics_account_link - mock_val = resources.AnalyticsAccountLink(name="name_value") - assert arg == mock_val - - -def test_create_analytics_account_link_flattened_error(): - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.create_analytics_account_link( - marketingplatform_admin.CreateAnalyticsAccountLinkRequest(), - parent="parent_value", - analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), - ) - - -@pytest.mark.asyncio -async def test_create_analytics_account_link_flattened_async(): - client = MarketingplatformAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - ) - - # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.create_analytics_account_link), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = resources.AnalyticsAccountLink() - - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AnalyticsAccountLink() - ) - # Call the method with a truthy value for each flattened field, - # using the keyword arguments to the method. - response = await client.create_analytics_account_link( - parent="parent_value", - analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), - ) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(call.mock_calls) - _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" - assert arg == mock_val - arg = args[0].analytics_account_link - mock_val = resources.AnalyticsAccountLink(name="name_value") - assert arg == mock_val - - -@pytest.mark.asyncio -async def test_create_analytics_account_link_flattened_error_async(): - client = MarketingplatformAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - await client.create_analytics_account_link( - marketingplatform_admin.CreateAnalyticsAccountLinkRequest(), - parent="parent_value", - analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), - ) - - @pytest.mark.parametrize( "request_type", [ - marketingplatform_admin.DeleteAnalyticsAccountLinkRequest, + marketingplatform_admin.ListAnalyticsAccountLinksRequest, dict, ], ) -def test_delete_analytics_account_link(request_type, transport: str = "grpc"): +def test_list_analytics_account_links(request_type, transport: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -2471,23 +2200,26 @@ def test_delete_analytics_account_link(request_type, transport: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = None - response = client.delete_analytics_account_link(request) + call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse( + next_page_token="next_page_token_value", + ) + response = client.list_analytics_account_links(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, pagers.ListAnalyticsAccountLinksPager) + assert response.next_page_token == "next_page_token_value" -def test_delete_analytics_account_link_non_empty_request_with_auto_populated_field(): +def test_list_analytics_account_links_non_empty_request_with_auto_populated_field(): # This test is a coverage failsafe to make sure that UUID4 fields are # automatically populated, according to AIP-4235, with non-empty requests. client = MarketingplatformAdminServiceClient( @@ -2498,26 +2230,28 @@ def test_delete_analytics_account_link_non_empty_request_with_auto_populated_fie # Populate all string fields in the request which are not UUID4 # since we want to check that UUID4 are populated automatically # if they meet the requirements of AIP 4235. - request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest( - name="name_value", + request = marketingplatform_admin.ListAnalyticsAccountLinksRequest( + parent="parent_value", + page_token="page_token_value", ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.delete_analytics_account_link(request=request) + client.list_analytics_account_links(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == marketingplatform_admin.DeleteAnalyticsAccountLinkRequest( - name="name_value", + assert args[0] == marketingplatform_admin.ListAnalyticsAccountLinksRequest( + parent="parent_value", + page_token="page_token_value", ) -def test_delete_analytics_account_link_use_cached_wrapped_rpc(): +def test_list_analytics_account_links_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -2532,7 +2266,7 @@ def test_delete_analytics_account_link_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_analytics_account_link + client._transport.list_analytics_account_links in client._transport._wrapped_methods ) @@ -2542,15 +2276,15 @@ def test_delete_analytics_account_link_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_analytics_account_link + client._transport.list_analytics_account_links ] = mock_rpc request = {} - client.delete_analytics_account_link(request) + client.list_analytics_account_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_analytics_account_link(request) + client.list_analytics_account_links(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -2558,7 +2292,7 @@ def test_delete_analytics_account_link_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_delete_analytics_account_link_async_use_cached_wrapped_rpc( +async def test_list_analytics_account_links_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -2575,7 +2309,7 @@ async def test_delete_analytics_account_link_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.delete_analytics_account_link + client._client._transport.list_analytics_account_links in client._client._transport._wrapped_methods ) @@ -2583,16 +2317,16 @@ async def test_delete_analytics_account_link_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.delete_analytics_account_link + client._client._transport.list_analytics_account_links ] = mock_rpc request = {} - await client.delete_analytics_account_link(request) + await client.list_analytics_account_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.delete_analytics_account_link(request) + await client.list_analytics_account_links(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -2600,9 +2334,9 @@ async def test_delete_analytics_account_link_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_delete_analytics_account_link_async( +async def test_list_analytics_account_links_async( transport: str = "grpc_asyncio", - request_type=marketingplatform_admin.DeleteAnalyticsAccountLinkRequest, + request_type=marketingplatform_admin.ListAnalyticsAccountLinksRequest, ): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), @@ -2615,44 +2349,49 @@ async def test_delete_analytics_account_link_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - response = await client.delete_analytics_account_link(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_analytics_account_links(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, pagers.ListAnalyticsAccountLinksAsyncPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.asyncio -async def test_delete_analytics_account_link_async_from_dict(): - await test_delete_analytics_account_link_async(request_type=dict) +async def test_list_analytics_account_links_async_from_dict(): + await test_list_analytics_account_links_async(request_type=dict) -def test_delete_analytics_account_link_field_headers(): +def test_list_analytics_account_links_field_headers(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) # Any value that is part of the HTTP/1.1 URI should be sent as # a field header. Set these to a non-empty value. - request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: - call.return_value = None - client.delete_analytics_account_link(request) + call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse() + client.list_analytics_account_links(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -2663,28 +2402,30 @@ def test_delete_analytics_account_link_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_delete_analytics_account_link_field_headers_async(): +async def test_list_analytics_account_links_field_headers_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Any value that is part of the HTTP/1.1 URI should be sent as # a field header. Set these to a non-empty value. - request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + request = marketingplatform_admin.ListAnalyticsAccountLinksRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_analytics_account_link(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ListAnalyticsAccountLinksResponse() + ) + await client.list_analytics_account_links(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -2695,37 +2436,37 @@ async def test_delete_analytics_account_link_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] -def test_delete_analytics_account_link_flattened(): +def test_list_analytics_account_links_flattened(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = None + call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.delete_analytics_account_link( - name="name_value", + client.list_analytics_account_links( + parent="parent_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" assert arg == mock_val -def test_delete_analytics_account_link_flattened_error(): +def test_list_analytics_account_links_flattened_error(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -2733,43 +2474,45 @@ def test_delete_analytics_account_link_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_analytics_account_link( - marketingplatform_admin.DeleteAnalyticsAccountLinkRequest(), - name="name_value", + client.list_analytics_account_links( + marketingplatform_admin.ListAnalyticsAccountLinksRequest(), + parent="parent_value", ) @pytest.mark.asyncio -async def test_delete_analytics_account_link_flattened_async(): +async def test_list_analytics_account_links_flattened_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.delete_analytics_account_link), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = None + call.return_value = marketingplatform_admin.ListAnalyticsAccountLinksResponse() - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ListAnalyticsAccountLinksResponse() + ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.delete_analytics_account_link( - name="name_value", + response = await client.list_analytics_account_links( + parent="parent_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" assert arg == mock_val @pytest.mark.asyncio -async def test_delete_analytics_account_link_flattened_error_async(): +async def test_list_analytics_account_links_flattened_error_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) @@ -2777,95 +2520,309 @@ async def test_delete_analytics_account_link_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.delete_analytics_account_link( - marketingplatform_admin.DeleteAnalyticsAccountLinkRequest(), - name="name_value", + await client.list_analytics_account_links( + marketingplatform_admin.ListAnalyticsAccountLinksRequest(), + parent="parent_value", ) -@pytest.mark.parametrize( - "request_type", - [ - marketingplatform_admin.SetPropertyServiceLevelRequest, - dict, - ], -) -def test_set_property_service_level(request_type, transport: str = "grpc"): +def test_list_analytics_account_links_pager(transport_name: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport=transport_name, ) - # 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.set_property_service_level), "__call__" + type(client.transport.list_analytics_account_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() - response = client.set_property_service_level(request) + # Set the response to a series of pages. + call.side_effect = ( + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + next_page_token="abc", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[], + next_page_token="def", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + ], + next_page_token="ghi", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + ), + RuntimeError, + ) - # Establish that the underlying gRPC stub method was called. - assert len(call.mock_calls) == 1 - _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.SetPropertyServiceLevelRequest() - assert args[0] == request + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_analytics_account_links( + request={}, retry=retry, timeout=timeout + ) - # Establish that the response is the type that we expect. - assert isinstance(response, marketingplatform_admin.SetPropertyServiceLevelResponse) + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.AnalyticsAccountLink) for i in results) -def test_set_property_service_level_non_empty_request_with_auto_populated_field(): - # This test is a coverage failsafe to make sure that UUID4 fields are - # automatically populated, according to AIP-4235, with non-empty requests. + +def test_list_analytics_account_links_pages(transport_name: str = "grpc"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport_name, ) - # Populate all string fields in the request which are not UUID4 - # since we want to check that UUID4 are populated automatically - # if they meet the requirements of AIP 4235. - request = marketingplatform_admin.SetPropertyServiceLevelRequest( - analytics_account_link="analytics_account_link_value", - analytics_property="analytics_property_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_analytics_account_links), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + next_page_token="abc", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[], + next_page_token="def", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + ], + next_page_token="ghi", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + ), + RuntimeError, + ) + pages = list(client.list_analytics_account_links(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_analytics_account_links_async_pager(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.set_property_service_level), "__call__" + type(client.transport.list_analytics_account_links), + "__call__", + new_callable=mock.AsyncMock, ) as call: - call.return_value.name = ( - "foo" # operation_request.operation in compute client(s) expect a string. + # Set the response to a series of pages. + call.side_effect = ( + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + next_page_token="abc", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[], + next_page_token="def", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + ], + next_page_token="ghi", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + ), + RuntimeError, ) - client.set_property_service_level(request=request) - call.assert_called() - _, args, _ = call.mock_calls[0] - assert args[0] == marketingplatform_admin.SetPropertyServiceLevelRequest( - analytics_account_link="analytics_account_link_value", - analytics_property="analytics_property_value", + async_pager = await client.list_analytics_account_links( + 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, resources.AnalyticsAccountLink) for i in responses) -def test_set_property_service_level_use_cached_wrapped_rpc(): - # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, - # instead of constructing them on each call - with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +@pytest.mark.asyncio +async def test_list_analytics_account_links_async_pages(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_analytics_account_links), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + next_page_token="abc", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[], + next_page_token="def", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + ], + next_page_token="ghi", + ), + marketingplatform_admin.ListAnalyticsAccountLinksResponse( + analytics_account_links=[ + resources.AnalyticsAccountLink(), + resources.AnalyticsAccountLink(), + ], + ), + 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_analytics_account_links(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", + [ + marketingplatform_admin.CreateAnalyticsAccountLinkRequest, + dict, + ], +) +def test_create_analytics_account_link(request_type, transport: str = "grpc"): + client = MarketingplatformAdminServiceClient( + 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.create_analytics_account_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.AnalyticsAccountLink( + name="name_value", + analytics_account="analytics_account_value", + display_name="display_name_value", + link_verification_state=resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED, + ) + response = client.create_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.AnalyticsAccountLink) + assert response.name == "name_value" + assert response.analytics_account == "analytics_account_value" + assert response.display_name == "display_name_value" + assert ( + response.link_verification_state + == resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED + ) + + +def test_create_analytics_account_link_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest( + parent="parent_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_analytics_account_link), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.create_analytics_account_link(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == marketingplatform_admin.CreateAnalyticsAccountLinkRequest( + parent="parent_value", + ) + + +def test_create_analytics_account_link_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() # Ensure method has been cached assert ( - client._transport.set_property_service_level + client._transport.create_analytics_account_link in client._transport._wrapped_methods ) @@ -2875,15 +2832,15 @@ def test_set_property_service_level_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.set_property_service_level + client._transport.create_analytics_account_link ] = mock_rpc request = {} - client.set_property_service_level(request) + client.create_analytics_account_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.set_property_service_level(request) + client.create_analytics_account_link(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -2891,7 +2848,7 @@ def test_set_property_service_level_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_set_property_service_level_async_use_cached_wrapped_rpc( +async def test_create_analytics_account_link_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -2908,7 +2865,7 @@ async def test_set_property_service_level_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.set_property_service_level + client._client._transport.create_analytics_account_link in client._client._transport._wrapped_methods ) @@ -2916,16 +2873,16 @@ async def test_set_property_service_level_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.set_property_service_level + client._client._transport.create_analytics_account_link ] = mock_rpc request = {} - await client.set_property_service_level(request) + await client.create_analytics_account_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.set_property_service_level(request) + await client.create_analytics_account_link(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -2933,9 +2890,9 @@ async def test_set_property_service_level_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_set_property_service_level_async( +async def test_create_analytics_account_link_async( transport: str = "grpc_asyncio", - request_type=marketingplatform_admin.SetPropertyServiceLevelRequest, + request_type=marketingplatform_admin.CreateAnalyticsAccountLinkRequest, ): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), @@ -2948,46 +2905,58 @@ async def test_set_property_service_level_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.set_property_service_level), "__call__" + type(client.transport.create_analytics_account_link), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - marketingplatform_admin.SetPropertyServiceLevelResponse() + resources.AnalyticsAccountLink( + name="name_value", + analytics_account="analytics_account_value", + display_name="display_name_value", + link_verification_state=resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED, + ) ) - response = await client.set_property_service_level(request) + response = await client.create_analytics_account_link(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = marketingplatform_admin.SetPropertyServiceLevelRequest() + request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, marketingplatform_admin.SetPropertyServiceLevelResponse) + assert isinstance(response, resources.AnalyticsAccountLink) + assert response.name == "name_value" + assert response.analytics_account == "analytics_account_value" + assert response.display_name == "display_name_value" + assert ( + response.link_verification_state + == resources.LinkVerificationState.LINK_VERIFICATION_STATE_VERIFIED + ) @pytest.mark.asyncio -async def test_set_property_service_level_async_from_dict(): - await test_set_property_service_level_async(request_type=dict) +async def test_create_analytics_account_link_async_from_dict(): + await test_create_analytics_account_link_async(request_type=dict) -def test_set_property_service_level_field_headers(): +def test_create_analytics_account_link_field_headers(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) # Any value that is part of the HTTP/1.1 URI should be sent as # a field header. Set these to a non-empty value. - request = marketingplatform_admin.SetPropertyServiceLevelRequest() + request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() - request.analytics_account_link = "analytics_account_link_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.set_property_service_level), "__call__" + type(client.transport.create_analytics_account_link), "__call__" ) as call: - call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() - client.set_property_service_level(request) + call.return_value = resources.AnalyticsAccountLink() + client.create_analytics_account_link(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -2998,30 +2967,30 @@ def test_set_property_service_level_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "analytics_account_link=analytics_account_link_value", + "parent=parent_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_set_property_service_level_field_headers_async(): +async def test_create_analytics_account_link_field_headers_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Any value that is part of the HTTP/1.1 URI should be sent as # a field header. Set these to a non-empty value. - request = marketingplatform_admin.SetPropertyServiceLevelRequest() + request = marketingplatform_admin.CreateAnalyticsAccountLinkRequest() - request.analytics_account_link = "analytics_account_link_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.set_property_service_level), "__call__" + type(client.transport.create_analytics_account_link), "__call__" ) as call: call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - marketingplatform_admin.SetPropertyServiceLevelResponse() + resources.AnalyticsAccountLink() ) - await client.set_property_service_level(request) + await client.create_analytics_account_link(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -3032,37 +3001,41 @@ async def test_set_property_service_level_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "analytics_account_link=analytics_account_link_value", + "parent=parent_value", ) in kw["metadata"] -def test_set_property_service_level_flattened(): +def test_create_analytics_account_link_flattened(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.set_property_service_level), "__call__" + type(client.transport.create_analytics_account_link), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + call.return_value = resources.AnalyticsAccountLink() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.set_property_service_level( - analytics_account_link="analytics_account_link_value", + client.create_analytics_account_link( + parent="parent_value", + analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val arg = args[0].analytics_account_link - mock_val = "analytics_account_link_value" + mock_val = resources.AnalyticsAccountLink(name="name_value") assert arg == mock_val -def test_set_property_service_level_flattened_error(): +def test_create_analytics_account_link_flattened_error(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -3070,45 +3043,721 @@ def test_set_property_service_level_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.set_property_service_level( - marketingplatform_admin.SetPropertyServiceLevelRequest(), - analytics_account_link="analytics_account_link_value", + client.create_analytics_account_link( + marketingplatform_admin.CreateAnalyticsAccountLinkRequest(), + parent="parent_value", + analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), ) @pytest.mark.asyncio -async def test_set_property_service_level_flattened_async(): +async def test_create_analytics_account_link_flattened_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.set_property_service_level), "__call__" + type(client.transport.create_analytics_account_link), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + call.return_value = resources.AnalyticsAccountLink() call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - marketingplatform_admin.SetPropertyServiceLevelResponse() + resources.AnalyticsAccountLink() ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.set_property_service_level( - analytics_account_link="analytics_account_link_value", + response = await client.create_analytics_account_link( + parent="parent_value", + analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val arg = args[0].analytics_account_link - mock_val = "analytics_account_link_value" + mock_val = resources.AnalyticsAccountLink(name="name_value") assert arg == mock_val @pytest.mark.asyncio -async def test_set_property_service_level_flattened_error_async(): +async def test_create_analytics_account_link_flattened_error_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.create_analytics_account_link( + marketingplatform_admin.CreateAnalyticsAccountLinkRequest(), + parent="parent_value", + analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), + ) + + +@pytest.mark.parametrize( + "request_type", + [ + marketingplatform_admin.DeleteAnalyticsAccountLinkRequest, + dict, + ], +) +def test_delete_analytics_account_link(request_type, transport: str = "grpc"): + client = MarketingplatformAdminServiceClient( + 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.delete_analytics_account_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_analytics_account_link_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_analytics_account_link), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_analytics_account_link(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == marketingplatform_admin.DeleteAnalyticsAccountLinkRequest( + name="name_value", + ) + + +def test_delete_analytics_account_link_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.delete_analytics_account_link + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.delete_analytics_account_link + ] = mock_rpc + request = {} + client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_analytics_account_link(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_analytics_account_link_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.delete_analytics_account_link + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.delete_analytics_account_link + ] = mock_rpc + + request = {} + await client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.delete_analytics_account_link(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_analytics_account_link_async( + transport: str = "grpc_asyncio", + request_type=marketingplatform_admin.DeleteAnalyticsAccountLinkRequest, +): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.delete_analytics_account_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_delete_analytics_account_link_async_from_dict(): + await test_delete_analytics_account_link_async(request_type=dict) + + +def test_delete_analytics_account_link_field_headers(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_analytics_account_link), "__call__" + ) as call: + call.return_value = None + client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_analytics_account_link_field_headers_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = marketingplatform_admin.DeleteAnalyticsAccountLinkRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_analytics_account_link), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_delete_analytics_account_link_flattened(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_analytics_account_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.delete_analytics_account_link( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_delete_analytics_account_link_flattened_error(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_analytics_account_link( + marketingplatform_admin.DeleteAnalyticsAccountLinkRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_delete_analytics_account_link_flattened_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_analytics_account_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.delete_analytics_account_link( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_delete_analytics_account_link_flattened_error_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.delete_analytics_account_link( + marketingplatform_admin.DeleteAnalyticsAccountLinkRequest(), + name="name_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + marketingplatform_admin.SetPropertyServiceLevelRequest, + dict, + ], +) +def test_set_property_service_level(request_type, transport: str = "grpc"): + client = MarketingplatformAdminServiceClient( + 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.set_property_service_level), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + response = client.set_property_service_level(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.SetPropertyServiceLevelRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, marketingplatform_admin.SetPropertyServiceLevelResponse) + + +def test_set_property_service_level_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = marketingplatform_admin.SetPropertyServiceLevelRequest( + analytics_account_link="analytics_account_link_value", + analytics_property="analytics_property_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.set_property_service_level), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.set_property_service_level(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == marketingplatform_admin.SetPropertyServiceLevelRequest( + analytics_account_link="analytics_account_link_value", + analytics_property="analytics_property_value", + ) + + +def test_set_property_service_level_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.set_property_service_level + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.set_property_service_level + ] = mock_rpc + request = {} + client.set_property_service_level(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.set_property_service_level(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_set_property_service_level_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.set_property_service_level + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.set_property_service_level + ] = mock_rpc + + request = {} + await client.set_property_service_level(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.set_property_service_level(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_set_property_service_level_async( + transport: str = "grpc_asyncio", + request_type=marketingplatform_admin.SetPropertyServiceLevelRequest, +): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.set_property_service_level), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.SetPropertyServiceLevelResponse() + ) + response = await client.set_property_service_level(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.SetPropertyServiceLevelRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, marketingplatform_admin.SetPropertyServiceLevelResponse) + + +@pytest.mark.asyncio +async def test_set_property_service_level_async_from_dict(): + await test_set_property_service_level_async(request_type=dict) + + +def test_set_property_service_level_field_headers(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = marketingplatform_admin.SetPropertyServiceLevelRequest() + + request.analytics_account_link = "analytics_account_link_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.set_property_service_level), "__call__" + ) as call: + call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + client.set_property_service_level(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "analytics_account_link=analytics_account_link_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_set_property_service_level_field_headers_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = marketingplatform_admin.SetPropertyServiceLevelRequest() + + request.analytics_account_link = "analytics_account_link_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.set_property_service_level), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.SetPropertyServiceLevelResponse() + ) + await client.set_property_service_level(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "analytics_account_link=analytics_account_link_value", + ) in kw["metadata"] + + +def test_set_property_service_level_flattened(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.set_property_service_level), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.set_property_service_level( + analytics_account_link="analytics_account_link_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].analytics_account_link + mock_val = "analytics_account_link_value" + assert arg == mock_val + + +def test_set_property_service_level_flattened_error(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.set_property_service_level( + marketingplatform_admin.SetPropertyServiceLevelRequest(), + analytics_account_link="analytics_account_link_value", + ) + + +@pytest.mark.asyncio +async def test_set_property_service_level_flattened_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.set_property_service_level), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.SetPropertyServiceLevelResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.set_property_service_level( + analytics_account_link="analytics_account_link_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].analytics_account_link + mock_val = "analytics_account_link_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_set_property_service_level_flattened_error_async(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), ) @@ -3122,6 +3771,345 @@ async def test_set_property_service_level_flattened_error_async(): ) +@pytest.mark.parametrize( + "request_type", + [ + marketingplatform_admin.ReportPropertyUsageRequest, + dict, + ], +) +def test_report_property_usage(request_type, transport: str = "grpc"): + client = MarketingplatformAdminServiceClient( + 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.report_property_usage), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = marketingplatform_admin.ReportPropertyUsageResponse() + response = client.report_property_usage(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.ReportPropertyUsageRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, marketingplatform_admin.ReportPropertyUsageResponse) + + +def test_report_property_usage_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = marketingplatform_admin.ReportPropertyUsageRequest( + organization="organization_value", + month="month_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.report_property_usage(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == marketingplatform_admin.ReportPropertyUsageRequest( + organization="organization_value", + month="month_value", + ) + + +def test_report_property_usage_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.report_property_usage + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.report_property_usage + ] = mock_rpc + request = {} + client.report_property_usage(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.report_property_usage(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_report_property_usage_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.report_property_usage + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.report_property_usage + ] = mock_rpc + + request = {} + await client.report_property_usage(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.report_property_usage(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_report_property_usage_async( + transport: str = "grpc_asyncio", + request_type=marketingplatform_admin.ReportPropertyUsageRequest, +): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.report_property_usage), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ReportPropertyUsageResponse() + ) + response = await client.report_property_usage(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = marketingplatform_admin.ReportPropertyUsageRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, marketingplatform_admin.ReportPropertyUsageResponse) + + +@pytest.mark.asyncio +async def test_report_property_usage_async_from_dict(): + await test_report_property_usage_async(request_type=dict) + + +def test_report_property_usage_field_headers(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = marketingplatform_admin.ReportPropertyUsageRequest() + + request.organization = "organization_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + call.return_value = marketingplatform_admin.ReportPropertyUsageResponse() + client.report_property_usage(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "organization=organization_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_report_property_usage_field_headers_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = marketingplatform_admin.ReportPropertyUsageRequest() + + request.organization = "organization_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ReportPropertyUsageResponse() + ) + await client.report_property_usage(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "organization=organization_value", + ) in kw["metadata"] + + +def test_report_property_usage_flattened(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = marketingplatform_admin.ReportPropertyUsageResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.report_property_usage( + organization="organization_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].organization + mock_val = "organization_value" + assert arg == mock_val + + +def test_report_property_usage_flattened_error(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.report_property_usage( + marketingplatform_admin.ReportPropertyUsageRequest(), + organization="organization_value", + ) + + +@pytest.mark.asyncio +async def test_report_property_usage_flattened_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = marketingplatform_admin.ReportPropertyUsageResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ReportPropertyUsageResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.report_property_usage( + organization="organization_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].organization + mock_val = "organization_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_report_property_usage_flattened_error_async(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.report_property_usage( + marketingplatform_admin.ReportPropertyUsageRequest(), + organization="organization_value", + ) + + def test_get_organization_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -3166,7 +4154,292 @@ def test_get_organization_rest_required_fields( transport_class = transports.MarketingplatformAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_organization._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_organization._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 = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = resources.Organization() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = resources.Organization.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_organization(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_organization_rest_unset_required_fields(): + transport = transports.MarketingplatformAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_organization._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_organization_rest_flattened(): + client = MarketingplatformAdminServiceClient( + 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 = resources.Organization() + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "organizations/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.Organization.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.get_organization(**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/v1alpha/{name=organizations/*}" % client.transport._host, args[1] + ) + + +def test_get_organization_rest_flattened_error(transport: str = "rest"): + client = MarketingplatformAdminServiceClient( + 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_organization( + marketingplatform_admin.GetOrganizationRequest(), + name="name_value", + ) + + +def test_list_organizations_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_organizations in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_organizations + ] = mock_rpc + + request = {} + client.list_organizations(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_organizations(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_organizations_rest_pager(transport: str = "rest"): + client = MarketingplatformAdminServiceClient( + 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 = ( + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), + resources.Organization(), + ], + next_page_token="abc", + ), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[], + next_page_token="def", + ), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + ], + next_page_token="ghi", + ), + marketingplatform_admin.ListOrganizationsResponse( + organizations=[ + resources.Organization(), + resources.Organization(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + marketingplatform_admin.ListOrganizationsResponse.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 = {} + + pager = client.list_organizations(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.Organization) for i in results) + + pages = list(client.list_organizations(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_find_sales_partner_managed_clients_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.find_sales_partner_managed_clients + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.find_sales_partner_managed_clients + ] = mock_rpc + + request = {} + client.find_sales_partner_managed_clients(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.find_sales_partner_managed_clients(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_find_sales_partner_managed_clients_rest_required_fields( + request_type=marketingplatform_admin.FindSalesPartnerManagedClientsRequest, +): + transport_class = transports.MarketingplatformAdminServiceRestTransport + + request_init = {} + request_init["organization"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -3177,21 +4450,21 @@ def test_get_organization_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_organization._get_unset_required_fields(jsonified_request) + ).find_sales_partner_managed_clients._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["organization"] = "organization_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_organization._get_unset_required_fields(jsonified_request) + ).find_sales_partner_managed_clients._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 "organization" in jsonified_request + assert jsonified_request["organization"] == "organization_value" client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3200,7 +4473,7 @@ def test_get_organization_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.Organization() + return_value = marketingplatform_admin.FindSalesPartnerManagedClientsResponse() # 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 @@ -3212,92 +4485,43 @@ def test_get_organization_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 # Convert return value to protobuf type - return_value = resources.Organization.pb(return_value) + return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse.pb( + return_value + ) + ) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.get_organization(request) + response = client.find_sales_partner_managed_clients(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_organization_rest_unset_required_fields(): +def test_find_sales_partner_managed_clients_rest_unset_required_fields(): transport = transports.MarketingplatformAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_organization._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_get_organization_rest_flattened(): - client = MarketingplatformAdminServiceClient( - 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 = resources.Organization() - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "organizations/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.Organization.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - - client.get_organization(**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/v1alpha/{name=organizations/*}" % client.transport._host, args[1] - ) - - -def test_get_organization_rest_flattened_error(transport: str = "rest"): - client = MarketingplatformAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + unset_fields = ( + transport.find_sales_partner_managed_clients._get_unset_required_fields({}) ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.get_organization( - marketingplatform_admin.GetOrganizationRequest(), - name="name_value", - ) + assert set(unset_fields) == (set(()) & set(("organization",))) def test_list_analytics_account_links_rest_use_cached_wrapped_rpc(): @@ -3702,7 +4926,191 @@ def test_create_analytics_account_link_rest_unset_required_fields(): ) -def test_create_analytics_account_link_rest_flattened(): +def test_create_analytics_account_link_rest_flattened(): + client = MarketingplatformAdminServiceClient( + 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 = resources.AnalyticsAccountLink() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "organizations/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.AnalyticsAccountLink.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.create_analytics_account_link(**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/v1alpha/{parent=organizations/*}/analyticsAccountLinks" + % client.transport._host, + args[1], + ) + + +def test_create_analytics_account_link_rest_flattened_error(transport: str = "rest"): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_analytics_account_link( + marketingplatform_admin.CreateAnalyticsAccountLinkRequest(), + parent="parent_value", + analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), + ) + + +def test_delete_analytics_account_link_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.delete_analytics_account_link + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.delete_analytics_account_link + ] = mock_rpc + + request = {} + client.delete_analytics_account_link(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_analytics_account_link(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_delete_analytics_account_link_rest_required_fields( + request_type=marketingplatform_admin.DeleteAnalyticsAccountLinkRequest, +): + transport_class = transports.MarketingplatformAdminServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_analytics_account_link._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_analytics_account_link._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 = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = None + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.delete_analytics_account_link(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_analytics_account_link_rest_unset_required_fields(): + transport = transports.MarketingplatformAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_analytics_account_link._get_unset_required_fields( + {} + ) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_analytics_account_link_rest_flattened(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -3711,42 +5119,39 @@ def test_create_analytics_account_link_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 = resources.AnalyticsAccountLink() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "organizations/sample1"} + sample_request = {"name": "organizations/sample1/analyticsAccountLinks/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), + name="name_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.AnalyticsAccountLink.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.create_analytics_account_link(**mock_args) + client.delete_analytics_account_link(**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/v1alpha/{parent=organizations/*}/analyticsAccountLinks" + "%s/v1alpha/{name=organizations/*/analyticsAccountLinks/*}" % client.transport._host, args[1], ) -def test_create_analytics_account_link_rest_flattened_error(transport: str = "rest"): +def test_delete_analytics_account_link_rest_flattened_error(transport: str = "rest"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -3755,14 +5160,13 @@ def test_create_analytics_account_link_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.create_analytics_account_link( - marketingplatform_admin.CreateAnalyticsAccountLinkRequest(), - parent="parent_value", - analytics_account_link=resources.AnalyticsAccountLink(name="name_value"), + client.delete_analytics_account_link( + marketingplatform_admin.DeleteAnalyticsAccountLinkRequest(), + name="name_value", ) -def test_delete_analytics_account_link_rest_use_cached_wrapped_rpc(): +def test_set_property_service_level_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -3777,7 +5181,7 @@ def test_delete_analytics_account_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_analytics_account_link + client._transport.set_property_service_level in client._transport._wrapped_methods ) @@ -3787,29 +5191,30 @@ def test_delete_analytics_account_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_analytics_account_link + client._transport.set_property_service_level ] = mock_rpc request = {} - client.delete_analytics_account_link(request) + client.set_property_service_level(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_analytics_account_link(request) + client.set_property_service_level(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_analytics_account_link_rest_required_fields( - request_type=marketingplatform_admin.DeleteAnalyticsAccountLinkRequest, +def test_set_property_service_level_rest_required_fields( + request_type=marketingplatform_admin.SetPropertyServiceLevelRequest, ): transport_class = transports.MarketingplatformAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["analytics_account_link"] = "" + request_init["analytics_property"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -3820,21 +5225,24 @@ def test_delete_analytics_account_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_analytics_account_link._get_unset_required_fields(jsonified_request) + ).set_property_service_level._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["analyticsAccountLink"] = "analytics_account_link_value" + jsonified_request["analyticsProperty"] = "analytics_property_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_analytics_account_link._get_unset_required_fields(jsonified_request) + ).set_property_service_level._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 "analyticsAccountLink" in jsonified_request + assert jsonified_request["analyticsAccountLink"] == "analytics_account_link_value" + assert "analyticsProperty" in jsonified_request + assert jsonified_request["analyticsProperty"] == "analytics_property_value" client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3843,7 +5251,7 @@ def test_delete_analytics_account_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() # 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 @@ -3855,38 +5263,51 @@ def test_delete_analytics_account_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "post", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = marketingplatform_admin.SetPropertyServiceLevelResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_analytics_account_link(request) + response = client.set_property_service_level(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_analytics_account_link_rest_unset_required_fields(): +def test_set_property_service_level_rest_unset_required_fields(): transport = transports.MarketingplatformAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_analytics_account_link._get_unset_required_fields( - {} + unset_fields = transport.set_property_service_level._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "analyticsAccountLink", + "analyticsProperty", + "serviceLevel", + ) + ) ) - assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_analytics_account_link_rest_flattened(): +def test_set_property_service_level_rest_flattened(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -3895,39 +5316,45 @@ def test_delete_analytics_account_link_rest_flattened(): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "organizations/sample1/analyticsAccountLinks/sample2"} + sample_request = { + "analytics_account_link": "organizations/sample1/analyticsAccountLinks/sample2" + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + analytics_account_link="analytics_account_link_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + # Convert return value to protobuf type + return_value = marketingplatform_admin.SetPropertyServiceLevelResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_analytics_account_link(**mock_args) + client.set_property_service_level(**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/v1alpha/{name=organizations/*/analyticsAccountLinks/*}" + "%s/v1alpha/{analytics_account_link=organizations/*/analyticsAccountLinks/*}:setPropertyServiceLevel" % client.transport._host, args[1], ) -def test_delete_analytics_account_link_rest_flattened_error(transport: str = "rest"): +def test_set_property_service_level_rest_flattened_error(transport: str = "rest"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -3936,13 +5363,13 @@ def test_delete_analytics_account_link_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.delete_analytics_account_link( - marketingplatform_admin.DeleteAnalyticsAccountLinkRequest(), - name="name_value", + client.set_property_service_level( + marketingplatform_admin.SetPropertyServiceLevelRequest(), + analytics_account_link="analytics_account_link_value", ) -def test_set_property_service_level_rest_use_cached_wrapped_rpc(): +def test_report_property_usage_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -3957,7 +5384,7 @@ def test_set_property_service_level_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.set_property_service_level + client._transport.report_property_usage in client._transport._wrapped_methods ) @@ -3967,30 +5394,30 @@ def test_set_property_service_level_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.set_property_service_level + client._transport.report_property_usage ] = mock_rpc request = {} - client.set_property_service_level(request) + client.report_property_usage(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.set_property_service_level(request) + client.report_property_usage(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_set_property_service_level_rest_required_fields( - request_type=marketingplatform_admin.SetPropertyServiceLevelRequest, +def test_report_property_usage_rest_required_fields( + request_type=marketingplatform_admin.ReportPropertyUsageRequest, ): transport_class = transports.MarketingplatformAdminServiceRestTransport request_init = {} - request_init["analytics_account_link"] = "" - request_init["analytics_property"] = "" + request_init["organization"] = "" + request_init["month"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -4001,24 +5428,24 @@ def test_set_property_service_level_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).set_property_service_level._get_unset_required_fields(jsonified_request) + ).report_property_usage._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["analyticsAccountLink"] = "analytics_account_link_value" - jsonified_request["analyticsProperty"] = "analytics_property_value" + jsonified_request["organization"] = "organization_value" + jsonified_request["month"] = "month_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).set_property_service_level._get_unset_required_fields(jsonified_request) + ).report_property_usage._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "analyticsAccountLink" in jsonified_request - assert jsonified_request["analyticsAccountLink"] == "analytics_account_link_value" - assert "analyticsProperty" in jsonified_request - assert jsonified_request["analyticsProperty"] == "analytics_property_value" + assert "organization" in jsonified_request + assert jsonified_request["organization"] == "organization_value" + assert "month" in jsonified_request + assert jsonified_request["month"] == "month_value" client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4027,7 +5454,7 @@ def test_set_property_service_level_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = marketingplatform_admin.SetPropertyServiceLevelResponse() + return_value = marketingplatform_admin.ReportPropertyUsageResponse() # 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 @@ -4049,7 +5476,7 @@ def test_set_property_service_level_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = marketingplatform_admin.SetPropertyServiceLevelResponse.pb( + return_value = marketingplatform_admin.ReportPropertyUsageResponse.pb( return_value ) json_return_value = json_format.MessageToJson(return_value) @@ -4058,32 +5485,31 @@ def test_set_property_service_level_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.set_property_service_level(request) + response = client.report_property_usage(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_set_property_service_level_rest_unset_required_fields(): +def test_report_property_usage_rest_unset_required_fields(): transport = transports.MarketingplatformAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.set_property_service_level._get_unset_required_fields({}) + unset_fields = transport.report_property_usage._get_unset_required_fields({}) assert set(unset_fields) == ( set(()) & set( ( - "analyticsAccountLink", - "analyticsProperty", - "serviceLevel", + "organization", + "month", ) ) ) -def test_set_property_service_level_rest_flattened(): +def test_report_property_usage_rest_flattened(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -4092,16 +5518,14 @@ def test_set_property_service_level_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 = marketingplatform_admin.SetPropertyServiceLevelResponse() + return_value = marketingplatform_admin.ReportPropertyUsageResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "analytics_account_link": "organizations/sample1/analyticsAccountLinks/sample2" - } + sample_request = {"organization": "organizations/sample1"} # get truthy value for each flattened field mock_args = dict( - analytics_account_link="analytics_account_link_value", + organization="organization_value", ) mock_args.update(sample_request) @@ -4109,7 +5533,7 @@ def test_set_property_service_level_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = marketingplatform_admin.SetPropertyServiceLevelResponse.pb( + return_value = marketingplatform_admin.ReportPropertyUsageResponse.pb( return_value ) json_return_value = json_format.MessageToJson(return_value) @@ -4117,20 +5541,20 @@ def test_set_property_service_level_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.set_property_service_level(**mock_args) + client.report_property_usage(**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/v1alpha/{analytics_account_link=organizations/*/analyticsAccountLinks/*}:setPropertyServiceLevel" + "%s/v1alpha/{organization=organizations/*}:reportPropertyUsage" % client.transport._host, args[1], ) -def test_set_property_service_level_rest_flattened_error(transport: str = "rest"): +def test_report_property_usage_rest_flattened_error(transport: str = "rest"): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -4139,9 +5563,9 @@ def test_set_property_service_level_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.set_property_service_level( - marketingplatform_admin.SetPropertyServiceLevelRequest(), - analytics_account_link="analytics_account_link_value", + client.report_property_usage( + marketingplatform_admin.ReportPropertyUsageRequest(), + organization="organization_value", ) @@ -4272,6 +5696,54 @@ def test_get_organization_empty_call_grpc(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_organizations_empty_call_grpc(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_organizations), "__call__" + ) as call: + call.return_value = marketingplatform_admin.ListOrganizationsResponse() + client.list_organizations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.ListOrganizationsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_find_sales_partner_managed_clients_empty_call_grpc(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.find_sales_partner_managed_clients), "__call__" + ) as call: + call.return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() + ) + client.find_sales_partner_managed_clients(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. def test_list_analytics_account_links_empty_call_grpc(): @@ -4364,6 +5836,29 @@ def test_set_property_service_level_empty_call_grpc(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_report_property_usage_empty_call_grpc(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + call.return_value = marketingplatform_admin.ReportPropertyUsageResponse() + client.report_property_usage(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.ReportPropertyUsageRequest() + + assert args[0] == request_msg + + def test_transport_kind_grpc_asyncio(): transport = MarketingplatformAdminServiceAsyncClient.get_transport_class( "grpc_asyncio" @@ -4381,27 +5876,83 @@ def test_initialize_client_w_grpc_asyncio(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. @pytest.mark.asyncio -async def test_get_organization_empty_call_grpc_asyncio(): +async def test_get_organization_empty_call_grpc_asyncio(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_organization), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.Organization( + name="name_value", + display_name="display_name_value", + ) + ) + await client.get_organization(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.GetOrganizationRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_list_organizations_empty_call_grpc_asyncio(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_organizations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ListOrganizationsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_organizations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.ListOrganizationsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_find_sales_partner_managed_clients_empty_call_grpc_asyncio(): client = MarketingplatformAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_organization), "__call__") as call: + with mock.patch.object( + type(client.transport.find_sales_partner_managed_clients), "__call__" + ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Organization( - name="name_value", - display_name="display_name_value", - ) + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() ) - await client.get_organization(request=None) + await client.find_sales_partner_managed_clients(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = marketingplatform_admin.GetOrganizationRequest() + request_msg = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() assert args[0] == request_msg @@ -4509,31 +6060,325 @@ async def test_set_property_service_level_empty_call_grpc_asyncio(): call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( marketingplatform_admin.SetPropertyServiceLevelResponse() ) - await client.set_property_service_level(request=None) + await client.set_property_service_level(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.SetPropertyServiceLevelRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_report_property_usage_empty_call_grpc_asyncio(): + client = MarketingplatformAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + marketingplatform_admin.ReportPropertyUsageResponse() + ) + await client.report_property_usage(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.ReportPropertyUsageRequest() + + assert args[0] == request_msg + + +def test_transport_kind_rest(): + transport = MarketingplatformAdminServiceClient.get_transport_class("rest")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "rest" + + +def test_get_organization_rest_bad_request( + request_type=marketingplatform_admin.GetOrganizationRequest, +): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "organizations/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_organization(request) + + +@pytest.mark.parametrize( + "request_type", + [ + marketingplatform_admin.GetOrganizationRequest, + dict, + ], +) +def test_get_organization_rest_call_success(request_type): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "organizations/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = resources.Organization( + name="name_value", + display_name="display_name_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = resources.Organization.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.get_organization(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Organization) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_organization_rest_interceptors(null_interceptor): + transport = transports.MarketingplatformAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MarketingplatformAdminServiceRestInterceptor(), + ) + client = MarketingplatformAdminServiceClient(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.MarketingplatformAdminServiceRestInterceptor, "post_get_organization" + ) as post, mock.patch.object( + transports.MarketingplatformAdminServiceRestInterceptor, + "post_get_organization_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MarketingplatformAdminServiceRestInterceptor, "pre_get_organization" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = marketingplatform_admin.GetOrganizationRequest.pb( + marketingplatform_admin.GetOrganizationRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = resources.Organization.to_json(resources.Organization()) + req.return_value.content = return_value + + request = marketingplatform_admin.GetOrganizationRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Organization() + post_with_metadata.return_value = resources.Organization(), metadata + + client.get_organization( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_organizations_rest_bad_request( + request_type=marketingplatform_admin.ListOrganizationsRequest, +): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a 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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_organizations(request) + + +@pytest.mark.parametrize( + "request_type", + [ + marketingplatform_admin.ListOrganizationsRequest, + dict, + ], +) +def test_list_organizations_rest_call_success(request_type): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = marketingplatform_admin.ListOrganizationsResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = marketingplatform_admin.ListOrganizationsResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.list_organizations(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListOrganizationsPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_organizations_rest_interceptors(null_interceptor): + transport = transports.MarketingplatformAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MarketingplatformAdminServiceRestInterceptor(), + ) + client = MarketingplatformAdminServiceClient(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.MarketingplatformAdminServiceRestInterceptor, + "post_list_organizations", + ) as post, mock.patch.object( + transports.MarketingplatformAdminServiceRestInterceptor, + "post_list_organizations_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MarketingplatformAdminServiceRestInterceptor, + "pre_list_organizations", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = marketingplatform_admin.ListOrganizationsRequest.pb( + marketingplatform_admin.ListOrganizationsRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = marketingplatform_admin.SetPropertyServiceLevelRequest() + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = marketingplatform_admin.ListOrganizationsResponse.to_json( + marketingplatform_admin.ListOrganizationsResponse() + ) + req.return_value.content = return_value - assert args[0] == request_msg + request = marketingplatform_admin.ListOrganizationsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = marketingplatform_admin.ListOrganizationsResponse() + post_with_metadata.return_value = ( + marketingplatform_admin.ListOrganizationsResponse(), + metadata, + ) + client.list_organizations( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) -def test_transport_kind_rest(): - transport = MarketingplatformAdminServiceClient.get_transport_class("rest")( - credentials=ga_credentials.AnonymousCredentials() - ) - assert transport.kind == "rest" + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_get_organization_rest_bad_request( - request_type=marketingplatform_admin.GetOrganizationRequest, +def test_find_sales_partner_managed_clients_rest_bad_request( + request_type=marketingplatform_admin.FindSalesPartnerManagedClientsRequest, ): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "organizations/sample1"} + request_init = {"organization": "organizations/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -4548,53 +6393,54 @@ def test_get_organization_rest_bad_request( response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_organization(request) + client.find_sales_partner_managed_clients(request) @pytest.mark.parametrize( "request_type", [ - marketingplatform_admin.GetOrganizationRequest, + marketingplatform_admin.FindSalesPartnerManagedClientsRequest, dict, ], ) -def test_get_organization_rest_call_success(request_type): +def test_find_sales_partner_managed_clients_rest_call_success(request_type): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "organizations/sample1"} + request_init = {"organization": "organizations/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = resources.Organization( - name="name_value", - display_name="display_name_value", - ) + return_value = marketingplatform_admin.FindSalesPartnerManagedClientsResponse() # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.Organization.pb(return_value) + return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse.pb( + return_value + ) + ) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.get_organization(request) + response = client.find_sales_partner_managed_clients(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Organization) - assert response.name == "name_value" - assert response.display_name == "display_name_value" + assert isinstance( + response, marketingplatform_admin.FindSalesPartnerManagedClientsResponse + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_organization_rest_interceptors(null_interceptor): +def test_find_sales_partner_managed_clients_rest_interceptors(null_interceptor): transport = transports.MarketingplatformAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -4608,18 +6454,20 @@ def test_get_organization_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.MarketingplatformAdminServiceRestInterceptor, "post_get_organization" + transports.MarketingplatformAdminServiceRestInterceptor, + "post_find_sales_partner_managed_clients", ) as post, mock.patch.object( transports.MarketingplatformAdminServiceRestInterceptor, - "post_get_organization_with_metadata", + "post_find_sales_partner_managed_clients_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.MarketingplatformAdminServiceRestInterceptor, "pre_get_organization" + transports.MarketingplatformAdminServiceRestInterceptor, + "pre_find_sales_partner_managed_clients", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = marketingplatform_admin.GetOrganizationRequest.pb( - marketingplatform_admin.GetOrganizationRequest() + pb_message = marketingplatform_admin.FindSalesPartnerManagedClientsRequest.pb( + marketingplatform_admin.FindSalesPartnerManagedClientsRequest() ) transcode.return_value = { "method": "post", @@ -4631,19 +6479,28 @@ def test_get_organization_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = resources.Organization.to_json(resources.Organization()) + return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse.to_json( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() + ) + ) req.return_value.content = return_value - request = marketingplatform_admin.GetOrganizationRequest() + request = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Organization() - post_with_metadata.return_value = resources.Organization(), metadata + post.return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse() + ) + post_with_metadata.return_value = ( + marketingplatform_admin.FindSalesPartnerManagedClientsResponse(), + metadata, + ) - client.get_organization( + client.find_sales_partner_managed_clients( request, metadata=[ ("key", "val"), @@ -5261,6 +7118,140 @@ def test_set_property_service_level_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() +def test_report_property_usage_rest_bad_request( + request_type=marketingplatform_admin.ReportPropertyUsageRequest, +): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"organization": "organizations/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.report_property_usage(request) + + +@pytest.mark.parametrize( + "request_type", + [ + marketingplatform_admin.ReportPropertyUsageRequest, + dict, + ], +) +def test_report_property_usage_rest_call_success(request_type): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"organization": "organizations/sample1"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = marketingplatform_admin.ReportPropertyUsageResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = marketingplatform_admin.ReportPropertyUsageResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.report_property_usage(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, marketingplatform_admin.ReportPropertyUsageResponse) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_report_property_usage_rest_interceptors(null_interceptor): + transport = transports.MarketingplatformAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MarketingplatformAdminServiceRestInterceptor(), + ) + client = MarketingplatformAdminServiceClient(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.MarketingplatformAdminServiceRestInterceptor, + "post_report_property_usage", + ) as post, mock.patch.object( + transports.MarketingplatformAdminServiceRestInterceptor, + "post_report_property_usage_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MarketingplatformAdminServiceRestInterceptor, + "pre_report_property_usage", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = marketingplatform_admin.ReportPropertyUsageRequest.pb( + marketingplatform_admin.ReportPropertyUsageRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = marketingplatform_admin.ReportPropertyUsageResponse.to_json( + marketingplatform_admin.ReportPropertyUsageResponse() + ) + req.return_value.content = return_value + + request = marketingplatform_admin.ReportPropertyUsageRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = marketingplatform_admin.ReportPropertyUsageResponse() + post_with_metadata.return_value = ( + marketingplatform_admin.ReportPropertyUsageResponse(), + metadata, + ) + + client.report_property_usage( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + def test_initialize_client_w_rest(): client = MarketingplatformAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -5288,6 +7279,50 @@ def test_get_organization_empty_call_rest(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_organizations_empty_call_rest(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_organizations), "__call__" + ) as call: + client.list_organizations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.ListOrganizationsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_find_sales_partner_managed_clients_empty_call_rest(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.find_sales_partner_managed_clients), "__call__" + ) as call: + client.find_sales_partner_managed_clients(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.FindSalesPartnerManagedClientsRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. def test_list_analytics_account_links_empty_call_rest(): @@ -5376,6 +7411,28 @@ def test_set_property_service_level_empty_call_rest(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_report_property_usage_empty_call_rest(): + client = MarketingplatformAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.report_property_usage), "__call__" + ) as call: + client.report_property_usage(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = marketingplatform_admin.ReportPropertyUsageRequest() + + assert args[0] == request_msg + + def test_transport_grpc_default(): # A client should use the gRPC transport by default. client = MarketingplatformAdminServiceClient( @@ -5410,10 +7467,13 @@ def test_marketingplatform_admin_service_base_transport(): # raise NotImplementedError. methods = ( "get_organization", + "list_organizations", + "find_sales_partner_managed_clients", "list_analytics_account_links", "create_analytics_account_link", "delete_analytics_account_link", "set_property_service_level", + "report_property_usage", ) for method in methods: with pytest.raises(NotImplementedError): @@ -5698,6 +7758,12 @@ def test_marketingplatform_admin_service_client_transport_session_collision( session1 = client1.transport.get_organization._session session2 = client2.transport.get_organization._session assert session1 != session2 + session1 = client1.transport.list_organizations._session + session2 = client2.transport.list_organizations._session + assert session1 != session2 + session1 = client1.transport.find_sales_partner_managed_clients._session + session2 = client2.transport.find_sales_partner_managed_clients._session + assert session1 != session2 session1 = client1.transport.list_analytics_account_links._session session2 = client2.transport.list_analytics_account_links._session assert session1 != session2 @@ -5710,6 +7776,9 @@ def test_marketingplatform_admin_service_client_transport_session_collision( session1 = client1.transport.set_property_service_level._session session2 = client2.transport.set_property_service_level._session assert session1 != session2 + session1 = client1.transport.report_property_usage._session + session2 = client2.transport.report_property_usage._session + assert session1 != session2 def test_marketingplatform_admin_service_grpc_transport_channel(): diff --git a/packages/google-cloud-cloudsecuritycompliance/.repo-metadata.json b/packages/google-cloud-cloudsecuritycompliance/.repo-metadata.json index c38f20636d37..a1bf1b7ff2f7 100644 --- a/packages/google-cloud-cloudsecuritycompliance/.repo-metadata.json +++ b/packages/google-cloud-cloudsecuritycompliance/.repo-metadata.json @@ -1,7 +1,7 @@ { "name": "google-cloud-cloudsecuritycompliance", "name_pretty": "Cloud Security Compliance API", - "api_description": "null ", + "api_description": "", "product_documentation": "https://cloud.google.com/security-command-center/docs/compliance-manager-overview", "client_documentation": "https://cloud.google.com/python/docs/reference/google-cloud-cloudsecuritycompliance/latest", "issue_tracker": "https://issuetracker.google.com/issues/new?component=1761967&template=0", @@ -13,4 +13,4 @@ "api_id": "cloudsecuritycompliance.googleapis.com", "default_version": "v1", "api_shortname": "cloudsecuritycompliance" -} \ No newline at end of file +} diff --git a/packages/google-cloud-cloudsecuritycompliance/README.rst b/packages/google-cloud-cloudsecuritycompliance/README.rst index a7ef9b9ab0e8..03efe1d74619 100644 --- a/packages/google-cloud-cloudsecuritycompliance/README.rst +++ b/packages/google-cloud-cloudsecuritycompliance/README.rst @@ -3,7 +3,7 @@ Python Client for Cloud Security Compliance API |preview| |pypi| |versions| -`Cloud Security Compliance API`_: null +`Cloud Security Compliance API`_: - `Client Library Documentation`_ - `Product Documentation`_ diff --git a/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/monitoring.rst b/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/monitoring.rst new file mode 100644 index 000000000000..4d9f179eb398 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/monitoring.rst @@ -0,0 +1,10 @@ +Monitoring +---------------------------- + +.. automodule:: google.cloud.cloudsecuritycompliance_v1.services.monitoring + :members: + :inherited-members: + +.. automodule:: google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers + :members: + :inherited-members: diff --git a/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/services_.rst b/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/services_.rst index 80065d89c786..4b9aa6cfeb0c 100644 --- a/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/services_.rst +++ b/packages/google-cloud-cloudsecuritycompliance/docs/cloudsecuritycompliance_v1/services_.rst @@ -7,3 +7,4 @@ Services for Google Cloud Cloudsecuritycompliance v1 API cm_enrollment_service config deployment + monitoring diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance/__init__.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance/__init__.py index 302f8b8c6666..b4c89c91615c 100644 --- a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance/__init__.py +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance/__init__.py @@ -38,6 +38,12 @@ from google.cloud.cloudsecuritycompliance_v1.services.deployment.client import ( DeploymentClient, ) +from google.cloud.cloudsecuritycompliance_v1.services.monitoring.async_client import ( + MonitoringAsyncClient, +) +from google.cloud.cloudsecuritycompliance_v1.services.monitoring.client import ( + MonitoringClient, +) from google.cloud.cloudsecuritycompliance_v1.types.audit import ( BucketDestination, CloudControlAuditDetails, @@ -126,6 +132,30 @@ TargetResourceConfig, TargetResourceCreationConfig, ) +from google.cloud.cloudsecuritycompliance_v1.types.monitoring import ( + AggregatedComplianceReport, + AggregateFrameworkComplianceReportRequest, + AggregateFrameworkComplianceReportResponse, + CloudControlAssessmentDetails, + CloudControlReport, + ControlAssessmentDetails, + ControlComplianceSummary, + EvaluationState, + FetchFrameworkComplianceReportRequest, + FindingClass, + FindingSummary, + FrameworkComplianceReport, + FrameworkComplianceSummary, + ListControlComplianceSummariesRequest, + ListControlComplianceSummariesResponse, + ListFindingSummariesRequest, + ListFindingSummariesResponse, + ListFrameworkComplianceSummariesRequest, + ListFrameworkComplianceSummariesResponse, + ManualCloudControlAssessmentDetails, + SimilarControls, + TargetResourceDetails, +) __all__ = ( "AuditClient", @@ -136,6 +166,8 @@ "ConfigAsyncClient", "DeploymentClient", "DeploymentAsyncClient", + "MonitoringClient", + "MonitoringAsyncClient", "BucketDestination", "CloudControlAuditDetails", "CloudControlGroupAuditDetails", @@ -214,4 +246,26 @@ "TargetResourceConfig", "TargetResourceCreationConfig", "DeploymentState", + "AggregatedComplianceReport", + "AggregateFrameworkComplianceReportRequest", + "AggregateFrameworkComplianceReportResponse", + "CloudControlAssessmentDetails", + "CloudControlReport", + "ControlAssessmentDetails", + "ControlComplianceSummary", + "FetchFrameworkComplianceReportRequest", + "FindingSummary", + "FrameworkComplianceReport", + "FrameworkComplianceSummary", + "ListControlComplianceSummariesRequest", + "ListControlComplianceSummariesResponse", + "ListFindingSummariesRequest", + "ListFindingSummariesResponse", + "ListFrameworkComplianceSummariesRequest", + "ListFrameworkComplianceSummariesResponse", + "ManualCloudControlAssessmentDetails", + "SimilarControls", + "TargetResourceDetails", + "EvaluationState", + "FindingClass", ) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/__init__.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/__init__.py index 60e3e13d2a7e..87e375596324 100644 --- a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/__init__.py +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/__init__.py @@ -25,6 +25,7 @@ ) from .services.config import ConfigAsyncClient, ConfigClient from .services.deployment import DeploymentAsyncClient, DeploymentClient +from .services.monitoring import MonitoringAsyncClient, MonitoringClient from .types.audit import ( BucketDestination, CloudControlAuditDetails, @@ -113,12 +114,40 @@ TargetResourceConfig, TargetResourceCreationConfig, ) +from .types.monitoring import ( + AggregatedComplianceReport, + AggregateFrameworkComplianceReportRequest, + AggregateFrameworkComplianceReportResponse, + CloudControlAssessmentDetails, + CloudControlReport, + ControlAssessmentDetails, + ControlComplianceSummary, + EvaluationState, + FetchFrameworkComplianceReportRequest, + FindingClass, + FindingSummary, + FrameworkComplianceReport, + FrameworkComplianceSummary, + ListControlComplianceSummariesRequest, + ListControlComplianceSummariesResponse, + ListFindingSummariesRequest, + ListFindingSummariesResponse, + ListFrameworkComplianceSummariesRequest, + ListFrameworkComplianceSummariesResponse, + ManualCloudControlAssessmentDetails, + SimilarControls, + TargetResourceDetails, +) __all__ = ( "AuditAsyncClient", "CmEnrollmentServiceAsyncClient", "ConfigAsyncClient", "DeploymentAsyncClient", + "MonitoringAsyncClient", + "AggregateFrameworkComplianceReportRequest", + "AggregateFrameworkComplianceReportResponse", + "AggregatedComplianceReport", "AllowedValues", "AttributeSubstitutionRule", "AuditClient", @@ -128,6 +157,7 @@ "CalculateEffectiveCmEnrollmentRequest", "CalculateEffectiveCmEnrollmentResponse", "CloudControl", + "CloudControlAssessmentDetails", "CloudControlAuditDetails", "CloudControlCategory", "CloudControlDeployment", @@ -135,11 +165,14 @@ "CloudControlDetails", "CloudControlGroupAuditDetails", "CloudControlMetadata", + "CloudControlReport", "CloudProvider", "CmEnrollment", "CmEnrollmentServiceClient", "ComplianceState", "ConfigClient", + "ControlAssessmentDetails", + "ControlComplianceSummary", "ControlFamily", "CreateCloudControlRequest", "CreateFrameworkAuditRequest", @@ -151,13 +184,19 @@ "DeploymentClient", "DeploymentState", "EnforcementMode", + "EvaluationState", "EvidenceDetails", + "FetchFrameworkComplianceReportRequest", + "FindingClass", "FindingDetails", + "FindingSummary", "FolderCreationConfig", "Framework", "FrameworkAudit", "FrameworkAuditDestination", "FrameworkCategory", + "FrameworkComplianceReport", + "FrameworkComplianceSummary", "FrameworkDeployment", "FrameworkDeploymentReference", "FrameworkReference", @@ -173,12 +212,20 @@ "ListCloudControlDeploymentsResponse", "ListCloudControlsRequest", "ListCloudControlsResponse", + "ListControlComplianceSummariesRequest", + "ListControlComplianceSummariesResponse", + "ListFindingSummariesRequest", + "ListFindingSummariesResponse", "ListFrameworkAuditsRequest", "ListFrameworkAuditsResponse", + "ListFrameworkComplianceSummariesRequest", + "ListFrameworkComplianceSummariesResponse", "ListFrameworkDeploymentsRequest", "ListFrameworkDeploymentsResponse", "ListFrameworksRequest", "ListFrameworksResponse", + "ManualCloudControlAssessmentDetails", + "MonitoringClient", "ObservationDetails", "OperationMetadata", "ParamValue", @@ -193,9 +240,11 @@ "Rule", "RuleActionType", "Severity", + "SimilarControls", "StringList", "TargetResourceConfig", "TargetResourceCreationConfig", + "TargetResourceDetails", "TargetResourceType", "UpdateCloudControlRequest", "UpdateCmEnrollmentRequest", diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/gapic_metadata.json b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/gapic_metadata.json index cda696c6068c..91c3d80353af 100644 --- a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/gapic_metadata.json +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/gapic_metadata.json @@ -410,6 +410,100 @@ } } } + }, + "Monitoring": { + "clients": { + "grpc": { + "libraryClient": "MonitoringClient", + "rpcs": { + "AggregateFrameworkComplianceReport": { + "methods": [ + "aggregate_framework_compliance_report" + ] + }, + "FetchFrameworkComplianceReport": { + "methods": [ + "fetch_framework_compliance_report" + ] + }, + "ListControlComplianceSummaries": { + "methods": [ + "list_control_compliance_summaries" + ] + }, + "ListFindingSummaries": { + "methods": [ + "list_finding_summaries" + ] + }, + "ListFrameworkComplianceSummaries": { + "methods": [ + "list_framework_compliance_summaries" + ] + } + } + }, + "grpc-async": { + "libraryClient": "MonitoringAsyncClient", + "rpcs": { + "AggregateFrameworkComplianceReport": { + "methods": [ + "aggregate_framework_compliance_report" + ] + }, + "FetchFrameworkComplianceReport": { + "methods": [ + "fetch_framework_compliance_report" + ] + }, + "ListControlComplianceSummaries": { + "methods": [ + "list_control_compliance_summaries" + ] + }, + "ListFindingSummaries": { + "methods": [ + "list_finding_summaries" + ] + }, + "ListFrameworkComplianceSummaries": { + "methods": [ + "list_framework_compliance_summaries" + ] + } + } + }, + "rest": { + "libraryClient": "MonitoringClient", + "rpcs": { + "AggregateFrameworkComplianceReport": { + "methods": [ + "aggregate_framework_compliance_report" + ] + }, + "FetchFrameworkComplianceReport": { + "methods": [ + "fetch_framework_compliance_report" + ] + }, + "ListControlComplianceSummaries": { + "methods": [ + "list_control_compliance_summaries" + ] + }, + "ListFindingSummaries": { + "methods": [ + "list_finding_summaries" + ] + }, + "ListFrameworkComplianceSummaries": { + "methods": [ + "list_framework_compliance_summaries" + ] + } + } + } + } } } } diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/__init__.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/__init__.py new file mode 100644 index 000000000000..e7c72c30d128 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/__init__.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from .async_client import MonitoringAsyncClient +from .client import MonitoringClient + +__all__ = ( + "MonitoringClient", + "MonitoringAsyncClient", +) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/async_client.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/async_client.py new file mode 100644 index 000000000000..915f2ac94bea --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/async_client.py @@ -0,0 +1,1270 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +import logging as std_logging +import re +from typing import ( + Callable, + Dict, + Mapping, + MutableMapping, + MutableSequence, + Optional, + Sequence, + Tuple, + Type, + Union, +) + +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1 +from google.api_core import retry_async as retries +from google.api_core.client_options import ClientOptions +from google.auth import credentials as ga_credentials # type: ignore +from google.oauth2 import service_account # type: ignore +import google.protobuf + +from google.cloud.cloudsecuritycompliance_v1 import gapic_version as package_version + +try: + OptionalRetry = Union[retries.AsyncRetry, gapic_v1.method._MethodDefault, None] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.AsyncRetry, object, None] # type: ignore + +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.services.monitoring import pagers +from google.cloud.cloudsecuritycompliance_v1.types import common, monitoring + +from .client import MonitoringClient +from .transports.base import DEFAULT_CLIENT_INFO, MonitoringTransport +from .transports.grpc_asyncio import MonitoringGrpcAsyncIOTransport + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + + +class MonitoringAsyncClient: + """Service describing handlers for resources""" + + _client: MonitoringClient + + # Copy defaults from the synchronous client for use here. + # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead. + DEFAULT_ENDPOINT = MonitoringClient.DEFAULT_ENDPOINT + DEFAULT_MTLS_ENDPOINT = MonitoringClient.DEFAULT_MTLS_ENDPOINT + _DEFAULT_ENDPOINT_TEMPLATE = MonitoringClient._DEFAULT_ENDPOINT_TEMPLATE + _DEFAULT_UNIVERSE = MonitoringClient._DEFAULT_UNIVERSE + + control_compliance_summary_path = staticmethod( + MonitoringClient.control_compliance_summary_path + ) + parse_control_compliance_summary_path = staticmethod( + MonitoringClient.parse_control_compliance_summary_path + ) + finding_summary_path = staticmethod(MonitoringClient.finding_summary_path) + parse_finding_summary_path = staticmethod( + MonitoringClient.parse_finding_summary_path + ) + framework_compliance_report_path = staticmethod( + MonitoringClient.framework_compliance_report_path + ) + parse_framework_compliance_report_path = staticmethod( + MonitoringClient.parse_framework_compliance_report_path + ) + framework_compliance_summary_path = staticmethod( + MonitoringClient.framework_compliance_summary_path + ) + parse_framework_compliance_summary_path = staticmethod( + MonitoringClient.parse_framework_compliance_summary_path + ) + common_billing_account_path = staticmethod( + MonitoringClient.common_billing_account_path + ) + parse_common_billing_account_path = staticmethod( + MonitoringClient.parse_common_billing_account_path + ) + common_folder_path = staticmethod(MonitoringClient.common_folder_path) + parse_common_folder_path = staticmethod(MonitoringClient.parse_common_folder_path) + common_organization_path = staticmethod(MonitoringClient.common_organization_path) + parse_common_organization_path = staticmethod( + MonitoringClient.parse_common_organization_path + ) + common_project_path = staticmethod(MonitoringClient.common_project_path) + parse_common_project_path = staticmethod(MonitoringClient.parse_common_project_path) + common_location_path = staticmethod(MonitoringClient.common_location_path) + parse_common_location_path = staticmethod( + MonitoringClient.parse_common_location_path + ) + + @classmethod + def from_service_account_info(cls, info: dict, *args, **kwargs): + """Creates an instance of this client using the provided credentials + info. + + Args: + info (dict): The service account private key info. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + MonitoringAsyncClient: The constructed client. + """ + return MonitoringClient.from_service_account_info.__func__(MonitoringAsyncClient, info, *args, **kwargs) # type: ignore + + @classmethod + def from_service_account_file(cls, filename: str, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + MonitoringAsyncClient: The constructed client. + """ + return MonitoringClient.from_service_account_file.__func__(MonitoringAsyncClient, filename, *args, **kwargs) # type: ignore + + from_service_account_json = from_service_account_file + + @classmethod + def get_mtls_endpoint_and_cert_source( + cls, client_options: Optional[ClientOptions] = None + ): + """Return the API endpoint and client cert source for mutual TLS. + + The client cert source is determined in the following order: + (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the + client cert source is None. + (2) if `client_options.client_cert_source` is provided, use the provided one; if the + default client cert source exists, use the default one; otherwise the client cert + source is None. + + The API endpoint is determined in the following order: + (1) if `client_options.api_endpoint` if provided, use the provided one. + (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the + default mTLS endpoint; if the environment variable is "never", use the default API + endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise + use the default API endpoint. + + More details can be found at https://google.aip.dev/auth/4114. + + Args: + client_options (google.api_core.client_options.ClientOptions): Custom options for the + client. Only the `api_endpoint` and `client_cert_source` properties may be used + in this method. + + Returns: + Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the + client cert source to use. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If any errors happen. + """ + return MonitoringClient.get_mtls_endpoint_and_cert_source(client_options) # type: ignore + + @property + def transport(self) -> MonitoringTransport: + """Returns the transport used by the client instance. + + Returns: + MonitoringTransport: The transport used by the client instance. + """ + return self._client.transport + + @property + def api_endpoint(self): + """Return the API endpoint used by the client instance. + + Returns: + str: The API endpoint used by the client instance. + """ + return self._client._api_endpoint + + @property + def universe_domain(self) -> str: + """Return the universe domain used by the client instance. + + Returns: + str: The universe domain used + by the client instance. + """ + return self._client._universe_domain + + get_transport_class = MonitoringClient.get_transport_class + + def __init__( + self, + *, + credentials: Optional[ga_credentials.Credentials] = None, + transport: Optional[ + Union[str, MonitoringTransport, Callable[..., MonitoringTransport]] + ] = "grpc_asyncio", + client_options: Optional[ClientOptions] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + ) -> None: + """Instantiates the monitoring async client. + + Args: + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + transport (Optional[Union[str,MonitoringTransport,Callable[..., MonitoringTransport]]]): + The transport to use, or a Callable that constructs and returns a new transport to use. + If a Callable is given, it will be called with the same set of initialization + arguments as used in the MonitoringTransport constructor. + If set to None, a transport is chosen automatically. + client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]): + Custom options for the client. + + 1. The ``api_endpoint`` property can be used to override the + default endpoint provided by the client when ``transport`` is + not explicitly provided. Only if this property is not set and + ``transport`` was not explicitly provided, the endpoint is + determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment + variable, which have one of the following values: + "always" (always use the default mTLS endpoint), "never" (always + use the default regular endpoint) and "auto" (auto-switch to the + default mTLS endpoint if client certificate is present; this is + the default value). + + 2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable + is "true", then the ``client_cert_source`` property can be used + to provide a client certificate for mTLS transport. If + not provided, the default SSL client certificate will be used if + present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not + set, no client certificate will be used. + + 3. The ``universe_domain`` property can be used to override the + default "googleapis.com" universe. Note that ``api_endpoint`` + property still takes precedence; and ``universe_domain`` is + currently not supported for mTLS. + + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + + Raises: + google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport + creation failed for any reason. + """ + self._client = MonitoringClient( + credentials=credentials, + transport=transport, + client_options=client_options, + client_info=client_info, + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ): # pragma: NO COVER + _LOGGER.debug( + "Created client `google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient`.", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "universeDomain": getattr( + self._client._transport._credentials, "universe_domain", "" + ), + "credentialsType": f"{type(self._client._transport._credentials).__module__}.{type(self._client._transport._credentials).__qualname__}", + "credentialsInfo": getattr( + self.transport._credentials, "get_cred_info", lambda: None + )(), + } + if hasattr(self._client._transport, "_credentials") + else { + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "credentialsType": None, + }, + ) + + async def list_framework_compliance_summaries( + self, + request: Optional[ + Union[monitoring.ListFrameworkComplianceSummariesRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListFrameworkComplianceSummariesAsyncPager: + r"""Lists the framework compliance summary for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + async def sample_list_framework_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFrameworkComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_framework_compliance_summaries(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesRequest, dict]]): + The request object. The request message for + [ListFrameworkComplianceSummariesRequest][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesRequest]. + parent (:class:`str`): + Required. The parent scope for the + framework compliance summary. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFrameworkComplianceSummariesAsyncPager: + The response message for + [ListFrameworkComplianceSummariesResponse][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesResponse]. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.ListFrameworkComplianceSummariesRequest): + request = monitoring.ListFrameworkComplianceSummariesRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.list_framework_compliance_summaries + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListFrameworkComplianceSummariesAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_finding_summaries( + self, + request: Optional[Union[monitoring.ListFindingSummariesRequest, dict]] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListFindingSummariesAsyncPager: + r"""Lists the finding summary by category for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + async def sample_list_finding_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFindingSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_finding_summaries(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesRequest, dict]]): + The request object. The request message for [ListFindingSummaries][]. + parent (:class:`str`): + Required. The parent scope for the + framework overview page. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFindingSummariesAsyncPager: + The response message for [ListFindingSummaries][]. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.ListFindingSummariesRequest): + request = monitoring.ListFindingSummariesRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.list_finding_summaries + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListFindingSummariesAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def fetch_framework_compliance_report( + self, + request: Optional[ + Union[monitoring.FetchFrameworkComplianceReportRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.FrameworkComplianceReport: + r"""Fetches the framework compliance report for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + async def sample_fetch_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.FetchFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = await client.fetch_framework_compliance_report(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.cloudsecuritycompliance_v1.types.FetchFrameworkComplianceReportRequest, dict]]): + The request object. The request message for + [FetchFrameworkComplianceReport][]. + name (:class:`str`): + Required. The name of the framework + compliance report to retrieve. + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.types.FrameworkComplianceReport: + The response message for + [GetFrameworkComplianceReport][]. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.FetchFrameworkComplianceReportRequest): + request = monitoring.FetchFrameworkComplianceReportRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.fetch_framework_compliance_report + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_control_compliance_summaries( + self, + request: Optional[ + Union[monitoring.ListControlComplianceSummariesRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListControlComplianceSummariesAsyncPager: + r"""Lists the control compliance summary for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + async def sample_list_control_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListControlComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_control_compliance_summaries(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesRequest, dict]]): + The request object. The request message for + [ListControlComplianceSummaries][]. + parent (:class:`str`): + Required. The parent scope for the + framework overview page. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListControlComplianceSummariesAsyncPager: + The response message for + [ListControlComplianceSummaries][]. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.ListControlComplianceSummariesRequest): + request = monitoring.ListControlComplianceSummariesRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.list_control_compliance_summaries + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListControlComplianceSummariesAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def aggregate_framework_compliance_report( + self, + request: Optional[ + Union[monitoring.AggregateFrameworkComplianceReportRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.AggregateFrameworkComplianceReportResponse: + r"""Gets the aggregated compliance report over time for a + given scope. + + .. 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 cloudsecuritycompliance_v1 + + async def sample_aggregate_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.AggregateFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = await client.aggregate_framework_compliance_report(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportRequest, dict]]): + The request object. The request message for + [AggregateFrameworkComplianceReport][]. + name (:class:`str`): + Required. The name of the aggregated compliance report + over time to retrieve. + + The supported format is: + ``organizations/{organization_id}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportResponse: + The response message for + [AggregateFrameworkComplianceReport][]. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance( + request, monitoring.AggregateFrameworkComplianceReportRequest + ): + request = monitoring.AggregateFrameworkComplianceReportRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.aggregate_framework_compliance_report + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_operations( + self, + request: Optional[operations_pb2.ListOperationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.ListOperationsResponse: + r"""Lists operations that match the specified filter in the request. + + Args: + request (:class:`~.operations_pb2.ListOperationsRequest`): + The request object. Request message for + `ListOperations` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.ListOperationsResponse: + Response message for ``ListOperations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.ListOperationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.list_operations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def get_operation( + self, + request: Optional[operations_pb2.GetOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Gets the latest state of a long-running operation. + + Args: + request (:class:`~.operations_pb2.GetOperationRequest`): + The request object. Request message for + `GetOperation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.Operation: + An ``Operation`` object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.GetOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.get_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def delete_operation( + self, + request: Optional[operations_pb2.DeleteOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a long-running operation. + + This method indicates that the client is no longer interested + in the operation result. It does not cancel the operation. + If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.DeleteOperationRequest`): + The request object. Request message for + `DeleteOperation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.DeleteOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.delete_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + async def cancel_operation( + self, + request: Optional[operations_pb2.CancelOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Starts asynchronous cancellation on a long-running operation. + + The server makes a best effort to cancel the operation, but success + is not guaranteed. If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.CancelOperationRequest`): + The request object. Request message for + `CancelOperation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.CancelOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.cancel_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + async def get_location( + self, + request: Optional[locations_pb2.GetLocationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.Location: + r"""Gets information about a location. + + Args: + request (:class:`~.location_pb2.GetLocationRequest`): + The request object. Request message for + `GetLocation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.Location: + Location object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.GetLocationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.get_location] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_locations( + self, + request: Optional[locations_pb2.ListLocationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.ListLocationsResponse: + r"""Lists information about the supported locations for this service. + + Args: + request (:class:`~.location_pb2.ListLocationsRequest`): + The request object. Request message for + `ListLocations` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.ListLocationsResponse: + Response message for ``ListLocations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.ListLocationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.list_locations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def __aenter__(self) -> "MonitoringAsyncClient": + return self + + async def __aexit__(self, exc_type, exc, tb): + await self.transport.close() + + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=package_version.__version__ +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + + +__all__ = ("MonitoringAsyncClient",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/client.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/client.py new file mode 100644 index 000000000000..ae294197466c --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/client.py @@ -0,0 +1,1757 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +from http import HTTPStatus +import json +import logging as std_logging +import os +import re +from typing import ( + Callable, + Dict, + Mapping, + MutableMapping, + MutableSequence, + Optional, + Sequence, + Tuple, + Type, + Union, + cast, +) +import warnings + +from google.api_core import client_options as client_options_lib +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1 +from google.api_core import retry as retries +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.exceptions import MutualTLSChannelError # type: ignore +from google.auth.transport import mtls # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.oauth2 import service_account # type: ignore +import google.protobuf + +from google.cloud.cloudsecuritycompliance_v1 import gapic_version as package_version + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object, None] # type: ignore + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.services.monitoring import pagers +from google.cloud.cloudsecuritycompliance_v1.types import common, monitoring + +from .transports.base import DEFAULT_CLIENT_INFO, MonitoringTransport +from .transports.grpc import MonitoringGrpcTransport +from .transports.grpc_asyncio import MonitoringGrpcAsyncIOTransport +from .transports.rest import MonitoringRestTransport + + +class MonitoringClientMeta(type): + """Metaclass for the Monitoring client. + + This provides class-level methods for building and retrieving + support objects (e.g. transport) without polluting the client instance + objects. + """ + + _transport_registry = OrderedDict() # type: Dict[str, Type[MonitoringTransport]] + _transport_registry["grpc"] = MonitoringGrpcTransport + _transport_registry["grpc_asyncio"] = MonitoringGrpcAsyncIOTransport + _transport_registry["rest"] = MonitoringRestTransport + + def get_transport_class( + cls, + label: Optional[str] = None, + ) -> Type[MonitoringTransport]: + """Returns an appropriate transport class. + + Args: + label: The name of the desired transport. If none is + provided, then the first transport in the registry is used. + + Returns: + The transport class to use. + """ + # If a specific transport is requested, return that one. + if label: + return cls._transport_registry[label] + + # No transport is requested; return the default (that is, the first one + # in the dictionary). + return next(iter(cls._transport_registry.values())) + + +class MonitoringClient(metaclass=MonitoringClientMeta): + """Service describing handlers for resources""" + + @staticmethod + def _get_default_mtls_endpoint(api_endpoint): + """Converts api endpoint to mTLS endpoint. + + Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to + "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively. + Args: + api_endpoint (Optional[str]): the api endpoint to convert. + Returns: + str: converted mTLS api endpoint. + """ + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead. + DEFAULT_ENDPOINT = "cloudsecuritycompliance.googleapis.com" + DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore + DEFAULT_ENDPOINT + ) + + _DEFAULT_ENDPOINT_TEMPLATE = "cloudsecuritycompliance.{UNIVERSE_DOMAIN}" + _DEFAULT_UNIVERSE = "googleapis.com" + + @classmethod + def from_service_account_info(cls, info: dict, *args, **kwargs): + """Creates an instance of this client using the provided credentials + info. + + Args: + info (dict): The service account private key info. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + MonitoringClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_info(info) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + @classmethod + def from_service_account_file(cls, filename: str, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + MonitoringClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_file(filename) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + from_service_account_json = from_service_account_file + + @property + def transport(self) -> MonitoringTransport: + """Returns the transport used by the client instance. + + Returns: + MonitoringTransport: The transport used by the client + instance. + """ + return self._transport + + @staticmethod + def control_compliance_summary_path( + project: str, + location: str, + framework_compliance_report: str, + control_compliance_summary: str, + ) -> str: + """Returns a fully-qualified control_compliance_summary string.""" + return "projects/{project}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}/controlComplianceSummaries/{control_compliance_summary}".format( + project=project, + location=location, + framework_compliance_report=framework_compliance_report, + control_compliance_summary=control_compliance_summary, + ) + + @staticmethod + def parse_control_compliance_summary_path(path: str) -> Dict[str, str]: + """Parses a control_compliance_summary path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/frameworkComplianceReports/(?P.+?)/controlComplianceSummaries/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + + @staticmethod + def finding_summary_path( + project: str, + location: str, + finding_summary: str, + ) -> str: + """Returns a fully-qualified finding_summary string.""" + return "projects/{project}/locations/{location}/findingSummaries/{finding_summary}".format( + project=project, + location=location, + finding_summary=finding_summary, + ) + + @staticmethod + def parse_finding_summary_path(path: str) -> Dict[str, str]: + """Parses a finding_summary path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/findingSummaries/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + + @staticmethod + def framework_compliance_report_path( + project: str, + location: str, + framework_compliance_report: str, + ) -> str: + """Returns a fully-qualified framework_compliance_report string.""" + return "projects/{project}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}".format( + project=project, + location=location, + framework_compliance_report=framework_compliance_report, + ) + + @staticmethod + def parse_framework_compliance_report_path(path: str) -> Dict[str, str]: + """Parses a framework_compliance_report path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/frameworkComplianceReports/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + + @staticmethod + def framework_compliance_summary_path( + project: str, + location: str, + framework_compliance_summary: str, + ) -> str: + """Returns a fully-qualified framework_compliance_summary string.""" + return "projects/{project}/locations/{location}/frameworkComplianceSummaries/{framework_compliance_summary}".format( + project=project, + location=location, + framework_compliance_summary=framework_compliance_summary, + ) + + @staticmethod + def parse_framework_compliance_summary_path(path: str) -> Dict[str, str]: + """Parses a framework_compliance_summary path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/frameworkComplianceSummaries/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + + @staticmethod + def common_billing_account_path( + billing_account: str, + ) -> str: + """Returns a fully-qualified billing_account string.""" + return "billingAccounts/{billing_account}".format( + billing_account=billing_account, + ) + + @staticmethod + def parse_common_billing_account_path(path: str) -> Dict[str, str]: + """Parse a billing_account path into its component segments.""" + m = re.match(r"^billingAccounts/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_folder_path( + folder: str, + ) -> str: + """Returns a fully-qualified folder string.""" + return "folders/{folder}".format( + folder=folder, + ) + + @staticmethod + def parse_common_folder_path(path: str) -> Dict[str, str]: + """Parse a folder path into its component segments.""" + m = re.match(r"^folders/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_organization_path( + organization: str, + ) -> str: + """Returns a fully-qualified organization string.""" + return "organizations/{organization}".format( + organization=organization, + ) + + @staticmethod + def parse_common_organization_path(path: str) -> Dict[str, str]: + """Parse a organization path into its component segments.""" + m = re.match(r"^organizations/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_project_path( + project: str, + ) -> str: + """Returns a fully-qualified project string.""" + return "projects/{project}".format( + project=project, + ) + + @staticmethod + def parse_common_project_path(path: str) -> Dict[str, str]: + """Parse a project path into its component segments.""" + m = re.match(r"^projects/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_location_path( + project: str, + location: str, + ) -> str: + """Returns a fully-qualified location string.""" + return "projects/{project}/locations/{location}".format( + project=project, + location=location, + ) + + @staticmethod + def parse_common_location_path(path: str) -> Dict[str, str]: + """Parse a location path into its component segments.""" + m = re.match(r"^projects/(?P.+?)/locations/(?P.+?)$", path) + return m.groupdict() if m else {} + + @classmethod + def get_mtls_endpoint_and_cert_source( + cls, client_options: Optional[client_options_lib.ClientOptions] = None + ): + """Deprecated. Return the API endpoint and client cert source for mutual TLS. + + The client cert source is determined in the following order: + (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the + client cert source is None. + (2) if `client_options.client_cert_source` is provided, use the provided one; if the + default client cert source exists, use the default one; otherwise the client cert + source is None. + + The API endpoint is determined in the following order: + (1) if `client_options.api_endpoint` if provided, use the provided one. + (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the + default mTLS endpoint; if the environment variable is "never", use the default API + endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise + use the default API endpoint. + + More details can be found at https://google.aip.dev/auth/4114. + + Args: + client_options (google.api_core.client_options.ClientOptions): Custom options for the + client. Only the `api_endpoint` and `client_cert_source` properties may be used + in this method. + + Returns: + Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the + client cert source to use. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If any errors happen. + """ + + warnings.warn( + "get_mtls_endpoint_and_cert_source is deprecated. Use the api_endpoint property instead.", + DeprecationWarning, + ) + if client_options is None: + client_options = client_options_lib.ClientOptions() + use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false") + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto") + if use_client_cert not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + # Figure out the client cert source to use. + client_cert_source = None + if use_client_cert == "true": + if client_options.client_cert_source: + client_cert_source = client_options.client_cert_source + elif mtls.has_default_client_cert_source(): + client_cert_source = mtls.default_client_cert_source() + + # Figure out which api endpoint to use. + if client_options.api_endpoint is not None: + api_endpoint = client_options.api_endpoint + elif use_mtls_endpoint == "always" or ( + use_mtls_endpoint == "auto" and client_cert_source + ): + api_endpoint = cls.DEFAULT_MTLS_ENDPOINT + else: + api_endpoint = cls.DEFAULT_ENDPOINT + + return api_endpoint, client_cert_source + + @staticmethod + def _read_environment_variables(): + """Returns the environment variables used by the client. + + Returns: + Tuple[bool, str, str]: returns the GOOGLE_API_USE_CLIENT_CERTIFICATE, + GOOGLE_API_USE_MTLS_ENDPOINT, and GOOGLE_CLOUD_UNIVERSE_DOMAIN environment variables. + + Raises: + ValueError: If GOOGLE_API_USE_CLIENT_CERTIFICATE is not + any of ["true", "false"]. + google.auth.exceptions.MutualTLSChannelError: If GOOGLE_API_USE_MTLS_ENDPOINT + is not any of ["auto", "never", "always"]. + """ + use_client_cert = os.getenv( + "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false" + ).lower() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_client_cert not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + return use_client_cert == "true", use_mtls_endpoint, universe_domain_env + + @staticmethod + def _get_client_cert_source(provided_cert_source, use_cert_flag): + """Return the client cert source to be used by the client. + + Args: + provided_cert_source (bytes): The client certificate source provided. + use_cert_flag (bool): A flag indicating whether to use the client certificate. + + Returns: + bytes or None: The client cert source to be used by the client. + """ + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif mtls.has_default_client_cert_source(): + client_cert_source = mtls.default_client_cert_source() + return client_cert_source + + @staticmethod + def _get_api_endpoint( + api_override, client_cert_source, universe_domain, use_mtls_endpoint + ): + """Return the API endpoint used by the client. + + Args: + api_override (str): The API endpoint override. If specified, this is always + the return value of this function and the other arguments are not used. + client_cert_source (bytes): The client certificate source used by the client. + universe_domain (str): The universe domain used by the client. + use_mtls_endpoint (str): How to use the mTLS endpoint, which depends also on the other parameters. + Possible values are "always", "auto", or "never". + + Returns: + str: The API endpoint to be used by the client. + """ + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or ( + use_mtls_endpoint == "auto" and client_cert_source + ): + _default_universe = MonitoringClient._DEFAULT_UNIVERSE + if universe_domain != _default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {_default_universe}." + ) + api_endpoint = MonitoringClient.DEFAULT_MTLS_ENDPOINT + else: + api_endpoint = MonitoringClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=universe_domain + ) + return api_endpoint + + @staticmethod + def _get_universe_domain( + client_universe_domain: Optional[str], universe_domain_env: Optional[str] + ) -> str: + """Return the universe domain used by the client. + + Args: + client_universe_domain (Optional[str]): The universe domain configured via the client options. + universe_domain_env (Optional[str]): The universe domain configured via the "GOOGLE_CLOUD_UNIVERSE_DOMAIN" environment variable. + + Returns: + str: The universe domain to be used by the client. + + Raises: + ValueError: If the universe domain is an empty string. + """ + universe_domain = MonitoringClient._DEFAULT_UNIVERSE + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + def _validate_universe_domain(self): + """Validates client's and credentials' universe domains are consistent. + + Returns: + bool: True iff the configured universe domain is valid. + + Raises: + ValueError: If the configured universe domain is not valid. + """ + + # NOTE (b/349488459): universe validation is disabled until further notice. + return True + + def _add_cred_info_for_auth_errors( + self, error: core_exceptions.GoogleAPICallError + ) -> None: + """Adds credential info string to error details for 401/403/404 errors. + + Args: + error (google.api_core.exceptions.GoogleAPICallError): The error to add the cred info. + """ + if error.code not in [ + HTTPStatus.UNAUTHORIZED, + HTTPStatus.FORBIDDEN, + HTTPStatus.NOT_FOUND, + ]: + return + + cred = self._transport._credentials + + # get_cred_info is only available in google-auth>=2.35.0 + if not hasattr(cred, "get_cred_info"): + return + + # ignore the type check since pypy test fails when get_cred_info + # is not available + cred_info = cred.get_cred_info() # type: ignore + if cred_info and hasattr(error._details, "append"): + error._details.append(json.dumps(cred_info)) + + @property + def api_endpoint(self): + """Return the API endpoint used by the client instance. + + Returns: + str: The API endpoint used by the client instance. + """ + return self._api_endpoint + + @property + def universe_domain(self) -> str: + """Return the universe domain used by the client instance. + + Returns: + str: The universe domain used by the client instance. + """ + return self._universe_domain + + def __init__( + self, + *, + credentials: Optional[ga_credentials.Credentials] = None, + transport: Optional[ + Union[str, MonitoringTransport, Callable[..., MonitoringTransport]] + ] = None, + client_options: Optional[Union[client_options_lib.ClientOptions, dict]] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + ) -> None: + """Instantiates the monitoring client. + + Args: + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + transport (Optional[Union[str,MonitoringTransport,Callable[..., MonitoringTransport]]]): + The transport to use, or a Callable that constructs and returns a new transport. + If a Callable is given, it will be called with the same set of initialization + arguments as used in the MonitoringTransport constructor. + If set to None, a transport is chosen automatically. + client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]): + Custom options for the client. + + 1. The ``api_endpoint`` property can be used to override the + default endpoint provided by the client when ``transport`` is + not explicitly provided. Only if this property is not set and + ``transport`` was not explicitly provided, the endpoint is + determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment + variable, which have one of the following values: + "always" (always use the default mTLS endpoint), "never" (always + use the default regular endpoint) and "auto" (auto-switch to the + default mTLS endpoint if client certificate is present; this is + the default value). + + 2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable + is "true", then the ``client_cert_source`` property can be used + to provide a client certificate for mTLS transport. If + not provided, the default SSL client certificate will be used if + present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not + set, no client certificate will be used. + + 3. The ``universe_domain`` property can be used to override the + default "googleapis.com" universe. Note that the ``api_endpoint`` + property still takes precedence; and ``universe_domain`` is + currently not supported for mTLS. + + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport + creation failed for any reason. + """ + self._client_options = client_options + if isinstance(self._client_options, dict): + self._client_options = client_options_lib.from_dict(self._client_options) + if self._client_options is None: + self._client_options = client_options_lib.ClientOptions() + self._client_options = cast( + client_options_lib.ClientOptions, self._client_options + ) + + universe_domain_opt = getattr(self._client_options, "universe_domain", None) + + ( + self._use_client_cert, + self._use_mtls_endpoint, + self._universe_domain_env, + ) = MonitoringClient._read_environment_variables() + self._client_cert_source = MonitoringClient._get_client_cert_source( + self._client_options.client_cert_source, self._use_client_cert + ) + self._universe_domain = MonitoringClient._get_universe_domain( + universe_domain_opt, self._universe_domain_env + ) + self._api_endpoint = None # updated below, depending on `transport` + + # Initialize the universe domain validation. + self._is_universe_domain_valid = False + + if CLIENT_LOGGING_SUPPORTED: # pragma: NO COVER + # Setup logging. + client_logging.initialize_logging() + + api_key_value = getattr(self._client_options, "api_key", None) + if api_key_value and credentials: + raise ValueError( + "client_options.api_key and credentials are mutually exclusive" + ) + + # Save or instantiate the transport. + # Ordinarily, we provide the transport, but allowing a custom transport + # instance provides an extensibility point for unusual situations. + transport_provided = isinstance(transport, MonitoringTransport) + if transport_provided: + # transport is a MonitoringTransport instance. + if credentials or self._client_options.credentials_file or api_key_value: + raise ValueError( + "When providing a transport instance, " + "provide its credentials directly." + ) + if self._client_options.scopes: + raise ValueError( + "When providing a transport instance, provide its scopes " + "directly." + ) + self._transport = cast(MonitoringTransport, transport) + self._api_endpoint = self._transport.host + + self._api_endpoint = self._api_endpoint or MonitoringClient._get_api_endpoint( + self._client_options.api_endpoint, + self._client_cert_source, + self._universe_domain, + self._use_mtls_endpoint, + ) + + if not transport_provided: + import google.auth._default # type: ignore + + if api_key_value and hasattr( + google.auth._default, "get_api_key_credentials" + ): + credentials = google.auth._default.get_api_key_credentials( + api_key_value + ) + + transport_init: Union[ + Type[MonitoringTransport], Callable[..., MonitoringTransport] + ] = ( + MonitoringClient.get_transport_class(transport) + if isinstance(transport, str) or transport is None + else cast(Callable[..., MonitoringTransport], transport) + ) + # initialize with the provided callable or the passed in class + self._transport = transport_init( + credentials=credentials, + credentials_file=self._client_options.credentials_file, + host=self._api_endpoint, + scopes=self._client_options.scopes, + client_cert_source_for_mtls=self._client_cert_source, + quota_project_id=self._client_options.quota_project_id, + client_info=client_info, + always_use_jwt_access=True, + api_audience=self._client_options.api_audience, + ) + + if "async" not in str(self._transport): + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ): # pragma: NO COVER + _LOGGER.debug( + "Created client `google.cloud.cloudsecuritycompliance_v1.MonitoringClient`.", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "universeDomain": getattr( + self._transport._credentials, "universe_domain", "" + ), + "credentialsType": f"{type(self._transport._credentials).__module__}.{type(self._transport._credentials).__qualname__}", + "credentialsInfo": getattr( + self.transport._credentials, "get_cred_info", lambda: None + )(), + } + if hasattr(self._transport, "_credentials") + else { + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "credentialsType": None, + }, + ) + + def list_framework_compliance_summaries( + self, + request: Optional[ + Union[monitoring.ListFrameworkComplianceSummariesRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListFrameworkComplianceSummariesPager: + r"""Lists the framework compliance summary for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + def sample_list_framework_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFrameworkComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_framework_compliance_summaries(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesRequest, dict]): + The request object. The request message for + [ListFrameworkComplianceSummariesRequest][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesRequest]. + parent (str): + Required. The parent scope for the + framework compliance summary. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFrameworkComplianceSummariesPager: + The response message for + [ListFrameworkComplianceSummariesResponse][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesResponse]. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.ListFrameworkComplianceSummariesRequest): + request = monitoring.ListFrameworkComplianceSummariesRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.list_framework_compliance_summaries + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListFrameworkComplianceSummariesPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def list_finding_summaries( + self, + request: Optional[Union[monitoring.ListFindingSummariesRequest, dict]] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListFindingSummariesPager: + r"""Lists the finding summary by category for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + def sample_list_finding_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFindingSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_finding_summaries(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesRequest, dict]): + The request object. The request message for [ListFindingSummaries][]. + parent (str): + Required. The parent scope for the + framework overview page. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFindingSummariesPager: + The response message for [ListFindingSummaries][]. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.ListFindingSummariesRequest): + request = monitoring.ListFindingSummariesRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_finding_summaries] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListFindingSummariesPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def fetch_framework_compliance_report( + self, + request: Optional[ + Union[monitoring.FetchFrameworkComplianceReportRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.FrameworkComplianceReport: + r"""Fetches the framework compliance report for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + def sample_fetch_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.FetchFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = client.fetch_framework_compliance_report(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.cloudsecuritycompliance_v1.types.FetchFrameworkComplianceReportRequest, dict]): + The request object. The request message for + [FetchFrameworkComplianceReport][]. + name (str): + Required. The name of the framework + compliance report to retrieve. + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.types.FrameworkComplianceReport: + The response message for + [GetFrameworkComplianceReport][]. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.FetchFrameworkComplianceReportRequest): + request = monitoring.FetchFrameworkComplianceReportRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.fetch_framework_compliance_report + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def list_control_compliance_summaries( + self, + request: Optional[ + Union[monitoring.ListControlComplianceSummariesRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListControlComplianceSummariesPager: + r"""Lists the control compliance summary for a given + scope. + + .. 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 cloudsecuritycompliance_v1 + + def sample_list_control_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListControlComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_control_compliance_summaries(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesRequest, dict]): + The request object. The request message for + [ListControlComplianceSummaries][]. + parent (str): + Required. The parent scope for the + framework overview page. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListControlComplianceSummariesPager: + The response message for + [ListControlComplianceSummaries][]. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, monitoring.ListControlComplianceSummariesRequest): + request = monitoring.ListControlComplianceSummariesRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.list_control_compliance_summaries + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListControlComplianceSummariesPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def aggregate_framework_compliance_report( + self, + request: Optional[ + Union[monitoring.AggregateFrameworkComplianceReportRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.AggregateFrameworkComplianceReportResponse: + r"""Gets the aggregated compliance report over time for a + given scope. + + .. 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 cloudsecuritycompliance_v1 + + def sample_aggregate_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.AggregateFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = client.aggregate_framework_compliance_report(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportRequest, dict]): + The request object. The request message for + [AggregateFrameworkComplianceReport][]. + name (str): + Required. The name of the aggregated compliance report + over time to retrieve. + + The supported format is: + ``organizations/{organization_id}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportResponse: + The response message for + [AggregateFrameworkComplianceReport][]. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance( + request, monitoring.AggregateFrameworkComplianceReportRequest + ): + request = monitoring.AggregateFrameworkComplianceReportRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.aggregate_framework_compliance_report + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def __enter__(self) -> "MonitoringClient": + return self + + def __exit__(self, type, value, traceback): + """Releases underlying transport's resources. + + .. warning:: + ONLY use as a context manager if the transport is NOT shared + with other clients! Exiting the with block will CLOSE the transport + and may cause errors in other clients! + """ + self.transport.close() + + def list_operations( + self, + request: Optional[operations_pb2.ListOperationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.ListOperationsResponse: + r"""Lists operations that match the specified filter in the request. + + Args: + request (:class:`~.operations_pb2.ListOperationsRequest`): + The request object. Request message for + `ListOperations` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.ListOperationsResponse: + Response message for ``ListOperations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.ListOperationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_operations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def get_operation( + self, + request: Optional[operations_pb2.GetOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Gets the latest state of a long-running operation. + + Args: + request (:class:`~.operations_pb2.GetOperationRequest`): + The request object. Request message for + `GetOperation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.Operation: + An ``Operation`` object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.GetOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def delete_operation( + self, + request: Optional[operations_pb2.DeleteOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a long-running operation. + + This method indicates that the client is no longer interested + in the operation result. It does not cancel the operation. + If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.DeleteOperationRequest`): + The request object. Request message for + `DeleteOperation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.DeleteOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.delete_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + def cancel_operation( + self, + request: Optional[operations_pb2.CancelOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Starts asynchronous cancellation on a long-running operation. + + The server makes a best effort to cancel the operation, but success + is not guaranteed. If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.CancelOperationRequest`): + The request object. Request message for + `CancelOperation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.CancelOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.cancel_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + def get_location( + self, + request: Optional[locations_pb2.GetLocationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.Location: + r"""Gets information about a location. + + Args: + request (:class:`~.location_pb2.GetLocationRequest`): + The request object. Request message for + `GetLocation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.Location: + Location object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.GetLocationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_location] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def list_locations( + self, + request: Optional[locations_pb2.ListLocationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.ListLocationsResponse: + r"""Lists information about the supported locations for this service. + + Args: + request (:class:`~.location_pb2.ListLocationsRequest`): + The request object. Request message for + `ListLocations` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.ListLocationsResponse: + Response message for ``ListLocations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.ListLocationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_locations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=package_version.__version__ +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + +__all__ = ("MonitoringClient",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/pagers.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/pagers.py new file mode 100644 index 000000000000..ba0032ac4612 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/pagers.py @@ -0,0 +1,517 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from typing import ( + Any, + AsyncIterator, + Awaitable, + Callable, + Iterator, + Optional, + Sequence, + Tuple, + Union, +) + +from google.api_core import gapic_v1 +from google.api_core import retry as retries +from google.api_core import retry_async as retries_async + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] + OptionalAsyncRetry = Union[ + retries_async.AsyncRetry, gapic_v1.method._MethodDefault, None + ] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object, None] # type: ignore + OptionalAsyncRetry = Union[retries_async.AsyncRetry, object, None] # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.types import monitoring + + +class ListFrameworkComplianceSummariesPager: + """A pager for iterating through ``list_framework_compliance_summaries`` requests. + + This class thinly wraps an initial + :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesResponse` object, and + provides an ``__iter__`` method to iterate through its + ``framework_compliance_summaries`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListFrameworkComplianceSummaries`` requests and continue to iterate + through the ``framework_compliance_summaries`` field on the + corresponding responses. + + All the usual :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesResponse` + 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[..., monitoring.ListFrameworkComplianceSummariesResponse], + request: monitoring.ListFrameworkComplianceSummariesRequest, + response: monitoring.ListFrameworkComplianceSummariesResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesRequest): + The initial request object. + response (google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = monitoring.ListFrameworkComplianceSummariesRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[monitoring.ListFrameworkComplianceSummariesResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[monitoring.FrameworkComplianceSummary]: + for page in self.pages: + yield from page.framework_compliance_summaries + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListFrameworkComplianceSummariesAsyncPager: + """A pager for iterating through ``list_framework_compliance_summaries`` requests. + + This class thinly wraps an initial + :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``framework_compliance_summaries`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListFrameworkComplianceSummaries`` requests and continue to iterate + through the ``framework_compliance_summaries`` field on the + corresponding responses. + + All the usual :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesResponse` + 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[monitoring.ListFrameworkComplianceSummariesResponse] + ], + request: monitoring.ListFrameworkComplianceSummariesRequest, + response: monitoring.ListFrameworkComplianceSummariesResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesRequest): + The initial request object. + response (google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = monitoring.ListFrameworkComplianceSummariesRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[monitoring.ListFrameworkComplianceSummariesResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__(self) -> AsyncIterator[monitoring.FrameworkComplianceSummary]: + async def async_generator(): + async for page in self.pages: + for response in page.framework_compliance_summaries: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListFindingSummariesPager: + """A pager for iterating through ``list_finding_summaries`` requests. + + This class thinly wraps an initial + :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesResponse` object, and + provides an ``__iter__`` method to iterate through its + ``finding_summaries`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListFindingSummaries`` requests and continue to iterate + through the ``finding_summaries`` field on the + corresponding responses. + + All the usual :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesResponse` + 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[..., monitoring.ListFindingSummariesResponse], + request: monitoring.ListFindingSummariesRequest, + response: monitoring.ListFindingSummariesResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesRequest): + The initial request object. + response (google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = monitoring.ListFindingSummariesRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[monitoring.ListFindingSummariesResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[monitoring.FindingSummary]: + for page in self.pages: + yield from page.finding_summaries + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListFindingSummariesAsyncPager: + """A pager for iterating through ``list_finding_summaries`` requests. + + This class thinly wraps an initial + :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``finding_summaries`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListFindingSummaries`` requests and continue to iterate + through the ``finding_summaries`` field on the + corresponding responses. + + All the usual :class:`google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesResponse` + 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[monitoring.ListFindingSummariesResponse]], + request: monitoring.ListFindingSummariesRequest, + response: monitoring.ListFindingSummariesResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesRequest): + The initial request object. + response (google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = monitoring.ListFindingSummariesRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages(self) -> AsyncIterator[monitoring.ListFindingSummariesResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__(self) -> AsyncIterator[monitoring.FindingSummary]: + async def async_generator(): + async for page in self.pages: + for response in page.finding_summaries: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListControlComplianceSummariesPager: + """A pager for iterating through ``list_control_compliance_summaries`` requests. + + This class thinly wraps an initial + :class:`google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesResponse` object, and + provides an ``__iter__`` method to iterate through its + ``control_compliance_summaries`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListControlComplianceSummaries`` requests and continue to iterate + through the ``control_compliance_summaries`` field on the + corresponding responses. + + All the usual :class:`google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesResponse` + 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[..., monitoring.ListControlComplianceSummariesResponse], + request: monitoring.ListControlComplianceSummariesRequest, + response: monitoring.ListControlComplianceSummariesResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesRequest): + The initial request object. + response (google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = monitoring.ListControlComplianceSummariesRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[monitoring.ListControlComplianceSummariesResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[monitoring.ControlComplianceSummary]: + for page in self.pages: + yield from page.control_compliance_summaries + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListControlComplianceSummariesAsyncPager: + """A pager for iterating through ``list_control_compliance_summaries`` requests. + + This class thinly wraps an initial + :class:`google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``control_compliance_summaries`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListControlComplianceSummaries`` requests and continue to iterate + through the ``control_compliance_summaries`` field on the + corresponding responses. + + All the usual :class:`google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesResponse` + 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[monitoring.ListControlComplianceSummariesResponse] + ], + request: monitoring.ListControlComplianceSummariesRequest, + response: monitoring.ListControlComplianceSummariesResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesRequest): + The initial request object. + response (google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = monitoring.ListControlComplianceSummariesRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[monitoring.ListControlComplianceSummariesResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__(self) -> AsyncIterator[monitoring.ControlComplianceSummary]: + async def async_generator(): + async for page in self.pages: + for response in page.control_compliance_summaries: + 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-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/README.rst b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/README.rst new file mode 100644 index 000000000000..5c05c5143cb9 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/README.rst @@ -0,0 +1,9 @@ + +transport inheritance structure +_______________________________ + +`MonitoringTransport` is the ABC for all transports. +- public child `MonitoringGrpcTransport` for sync gRPC transport (defined in `grpc.py`). +- public child `MonitoringGrpcAsyncIOTransport` for async gRPC transport (defined in `grpc_asyncio.py`). +- private child `_BaseMonitoringRestTransport` for base REST transport with inner classes `_BaseMETHOD` (defined in `rest_base.py`). +- public child `MonitoringRestTransport` for sync REST transport with inner classes `METHOD` derived from the parent's corresponding `_BaseMETHOD` classes (defined in `rest.py`). diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/__init__.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/__init__.py new file mode 100644 index 000000000000..9274f35fea83 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/__init__.py @@ -0,0 +1,36 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +from typing import Dict, Type + +from .base import MonitoringTransport +from .grpc import MonitoringGrpcTransport +from .grpc_asyncio import MonitoringGrpcAsyncIOTransport +from .rest import MonitoringRestInterceptor, MonitoringRestTransport + +# Compile a registry of transports. +_transport_registry = OrderedDict() # type: Dict[str, Type[MonitoringTransport]] +_transport_registry["grpc"] = MonitoringGrpcTransport +_transport_registry["grpc_asyncio"] = MonitoringGrpcAsyncIOTransport +_transport_registry["rest"] = MonitoringRestTransport + +__all__ = ( + "MonitoringTransport", + "MonitoringGrpcTransport", + "MonitoringGrpcAsyncIOTransport", + "MonitoringRestTransport", + "MonitoringRestInterceptor", +) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/base.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/base.py new file mode 100644 index 000000000000..e16f6d086f2b --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/base.py @@ -0,0 +1,368 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import abc +from typing import Awaitable, Callable, Dict, Optional, Sequence, Union + +import google.api_core +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1 +from google.api_core import retry as retries +import google.auth # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.oauth2 import service_account # type: ignore +import google.protobuf + +from google.cloud.cloudsecuritycompliance_v1 import gapic_version as package_version +from google.cloud.cloudsecuritycompliance_v1.types import monitoring + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=package_version.__version__ +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + + +class MonitoringTransport(abc.ABC): + """Abstract transport class for Monitoring.""" + + AUTH_SCOPES = ("https://www.googleapis.com/auth/cloud-platform",) + + DEFAULT_HOST: str = "cloudsecuritycompliance.googleapis.com" + + def __init__( + self, + *, + host: str = DEFAULT_HOST, + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + api_audience: Optional[str] = None, + **kwargs, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'cloudsecuritycompliance.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is mutually exclusive with credentials. This argument will be + removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A list of scopes. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + """ + + scopes_kwargs = {"scopes": scopes, "default_scopes": self.AUTH_SCOPES} + + # Save the scopes. + self._scopes = scopes + if not hasattr(self, "_ignore_credentials"): + self._ignore_credentials: bool = False + + # If no credentials are provided, then determine the appropriate + # defaults. + if credentials and credentials_file: + raise core_exceptions.DuplicateCredentialArgs( + "'credentials_file' and 'credentials' are mutually exclusive" + ) + + if credentials_file is not None: + credentials, _ = google.auth.load_credentials_from_file( + credentials_file, **scopes_kwargs, quota_project_id=quota_project_id + ) + elif credentials is None and not self._ignore_credentials: + credentials, _ = google.auth.default( + **scopes_kwargs, quota_project_id=quota_project_id + ) + # Don't apply audience if the credentials file passed from user. + if hasattr(credentials, "with_gdch_audience"): + credentials = credentials.with_gdch_audience( + api_audience if api_audience else host + ) + + # If the credentials are service account credentials, then always try to use self signed JWT. + if ( + always_use_jwt_access + and isinstance(credentials, service_account.Credentials) + and hasattr(service_account.Credentials, "with_always_use_jwt_access") + ): + credentials = credentials.with_always_use_jwt_access(True) + + # Save the credentials. + self._credentials = credentials + + # Save the hostname. Default to port 443 (HTTPS) if none is specified. + if ":" not in host: + host += ":443" + self._host = host + + @property + def host(self): + return self._host + + def _prep_wrapped_messages(self, client_info): + # Precompute the wrapped methods. + self._wrapped_methods = { + self.list_framework_compliance_summaries: gapic_v1.method.wrap_method( + self.list_framework_compliance_summaries, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.list_finding_summaries: gapic_v1.method.wrap_method( + self.list_finding_summaries, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.fetch_framework_compliance_report: gapic_v1.method.wrap_method( + self.fetch_framework_compliance_report, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.list_control_compliance_summaries: gapic_v1.method.wrap_method( + self.list_control_compliance_summaries, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.aggregate_framework_compliance_report: gapic_v1.method.wrap_method( + self.aggregate_framework_compliance_report, + default_retry=retries.Retry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.get_location: gapic_v1.method.wrap_method( + self.get_location, + default_timeout=None, + client_info=client_info, + ), + self.list_locations: gapic_v1.method.wrap_method( + self.list_locations, + default_timeout=None, + client_info=client_info, + ), + self.cancel_operation: gapic_v1.method.wrap_method( + self.cancel_operation, + default_timeout=None, + client_info=client_info, + ), + self.delete_operation: gapic_v1.method.wrap_method( + self.delete_operation, + default_timeout=None, + client_info=client_info, + ), + self.get_operation: gapic_v1.method.wrap_method( + self.get_operation, + default_timeout=None, + client_info=client_info, + ), + self.list_operations: gapic_v1.method.wrap_method( + self.list_operations, + default_timeout=None, + client_info=client_info, + ), + } + + def close(self): + """Closes resources associated with the transport. + + .. warning:: + Only call this method if the transport is NOT shared + with other clients - this may cause errors in other clients! + """ + raise NotImplementedError() + + @property + def list_framework_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListFrameworkComplianceSummariesRequest], + Union[ + monitoring.ListFrameworkComplianceSummariesResponse, + Awaitable[monitoring.ListFrameworkComplianceSummariesResponse], + ], + ]: + raise NotImplementedError() + + @property + def list_finding_summaries( + self, + ) -> Callable[ + [monitoring.ListFindingSummariesRequest], + Union[ + monitoring.ListFindingSummariesResponse, + Awaitable[monitoring.ListFindingSummariesResponse], + ], + ]: + raise NotImplementedError() + + @property + def fetch_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.FetchFrameworkComplianceReportRequest], + Union[ + monitoring.FrameworkComplianceReport, + Awaitable[monitoring.FrameworkComplianceReport], + ], + ]: + raise NotImplementedError() + + @property + def list_control_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListControlComplianceSummariesRequest], + Union[ + monitoring.ListControlComplianceSummariesResponse, + Awaitable[monitoring.ListControlComplianceSummariesResponse], + ], + ]: + raise NotImplementedError() + + @property + def aggregate_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.AggregateFrameworkComplianceReportRequest], + Union[ + monitoring.AggregateFrameworkComplianceReportResponse, + Awaitable[monitoring.AggregateFrameworkComplianceReportResponse], + ], + ]: + raise NotImplementedError() + + @property + def list_operations( + self, + ) -> Callable[ + [operations_pb2.ListOperationsRequest], + Union[ + operations_pb2.ListOperationsResponse, + Awaitable[operations_pb2.ListOperationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def get_operation( + self, + ) -> Callable[ + [operations_pb2.GetOperationRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def cancel_operation( + self, + ) -> Callable[[operations_pb2.CancelOperationRequest], None,]: + raise NotImplementedError() + + @property + def delete_operation( + self, + ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]: + raise NotImplementedError() + + @property + def get_location( + self, + ) -> Callable[ + [locations_pb2.GetLocationRequest], + Union[locations_pb2.Location, Awaitable[locations_pb2.Location]], + ]: + raise NotImplementedError() + + @property + def list_locations( + self, + ) -> Callable[ + [locations_pb2.ListLocationsRequest], + Union[ + locations_pb2.ListLocationsResponse, + Awaitable[locations_pb2.ListLocationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def kind(self) -> str: + raise NotImplementedError() + + +__all__ = ("MonitoringTransport",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/grpc.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/grpc.py new file mode 100644 index 000000000000..3ed517af1b0d --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/grpc.py @@ -0,0 +1,602 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import json +import logging as std_logging +import pickle +from typing import Callable, Dict, Optional, Sequence, Tuple, Union +import warnings + +from google.api_core import gapic_v1, grpc_helpers +import google.auth # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf.json_format import MessageToJson +import google.protobuf.message +import grpc # type: ignore +import proto # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.types import monitoring + +from .base import DEFAULT_CLIENT_INFO, MonitoringTransport + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + + +class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER + def intercept_unary_unary(self, continuation, client_call_details, request): + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ) + if logging_enabled: # pragma: NO COVER + request_metadata = client_call_details.metadata + if isinstance(request, proto.Message): + request_payload = type(request).to_json(request) + elif isinstance(request, google.protobuf.message.Message): + request_payload = MessageToJson(request) + else: + request_payload = f"{type(request).__name__}: {pickle.dumps(request)}" + + request_metadata = { + key: value.decode("utf-8") if isinstance(value, bytes) else value + for key, value in request_metadata + } + grpc_request = { + "payload": request_payload, + "requestMethod": "grpc", + "metadata": dict(request_metadata), + } + _LOGGER.debug( + f"Sending request for {client_call_details.method}", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": str(client_call_details.method), + "request": grpc_request, + "metadata": grpc_request["metadata"], + }, + ) + response = continuation(client_call_details, request) + if logging_enabled: # pragma: NO COVER + response_metadata = response.trailing_metadata() + # Convert gRPC metadata `` to list of tuples + metadata = ( + dict([(k, str(v)) for k, v in response_metadata]) + if response_metadata + else None + ) + result = response.result() + if isinstance(result, proto.Message): + response_payload = type(result).to_json(result) + elif isinstance(result, google.protobuf.message.Message): + response_payload = MessageToJson(result) + else: + response_payload = f"{type(result).__name__}: {pickle.dumps(result)}" + grpc_response = { + "payload": response_payload, + "metadata": metadata, + "status": "OK", + } + _LOGGER.debug( + f"Received response for {client_call_details.method}.", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": client_call_details.method, + "response": grpc_response, + "metadata": grpc_response["metadata"], + }, + ) + return response + + +class MonitoringGrpcTransport(MonitoringTransport): + """gRPC backend transport for Monitoring. + + Service describing handlers for resources + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends protocol buffers over the wire using gRPC (which is built on + top of HTTP/2); the ``grpcio`` package must be installed. + """ + + _stubs: Dict[str, Callable] + + def __init__( + self, + *, + host: str = "cloudsecuritycompliance.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + channel: Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]] = None, + api_mtls_endpoint: Optional[str] = None, + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'cloudsecuritycompliance.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is ignored if a ``channel`` instance is provided. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if a ``channel`` instance is provided. + This argument will be removed in the next major version of this library. + scopes (Optional(Sequence[str])): A list of scopes. This argument is + ignored if a ``channel`` instance is provided. + channel (Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]]): + A ``Channel`` instance through which to make calls, or a Callable + that constructs and returns one. If set to None, ``self.create_channel`` + is used to create the channel. If a Callable is given, it will be called + with the same arguments as used in ``self.create_channel``. + api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint. + If provided, it overrides the ``host`` argument and tries to create + a mutual TLS channel with client SSL credentials from + ``client_cert_source`` or application default SSL credentials. + client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): + Deprecated. A callback to provide client SSL certificate bytes and + private key bytes, both in PEM format. It is ignored if + ``api_mtls_endpoint`` is None. + ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials + for the grpc channel. It is ignored if a ``channel`` instance is provided. + client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]): + A callback to provide client certificate bytes and private key bytes, + both in PEM format. It is used to configure a mutual TLS channel. It is + ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport + creation failed for any reason. + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + self._grpc_channel = None + self._ssl_channel_credentials = ssl_channel_credentials + self._stubs: Dict[str, Callable] = {} + + if api_mtls_endpoint: + warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning) + if client_cert_source: + warnings.warn("client_cert_source is deprecated", DeprecationWarning) + + if isinstance(channel, grpc.Channel): + # Ignore credentials if a channel was passed. + credentials = None + self._ignore_credentials = True + # If a channel was explicitly provided, set it. + self._grpc_channel = channel + self._ssl_channel_credentials = None + + else: + if api_mtls_endpoint: + host = api_mtls_endpoint + + # Create SSL credentials with client_cert_source or application + # default SSL credentials. + if client_cert_source: + cert, key = client_cert_source() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + else: + self._ssl_channel_credentials = SslCredentials().ssl_credentials + + else: + if client_cert_source_for_mtls and not ssl_channel_credentials: + cert, key = client_cert_source_for_mtls() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + + # The base transport sets the host, credentials and scopes + super().__init__( + host=host, + credentials=credentials, + credentials_file=credentials_file, + scopes=scopes, + quota_project_id=quota_project_id, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + + if not self._grpc_channel: + # initialize with the provided callable or the default channel + channel_init = channel or type(self).create_channel + self._grpc_channel = channel_init( + self._host, + # use the credentials which are saved + credentials=self._credentials, + # Set ``credentials_file`` to ``None`` here as + # the credentials that we saved earlier should be used. + credentials_file=None, + scopes=self._scopes, + ssl_credentials=self._ssl_channel_credentials, + quota_project_id=quota_project_id, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + self._interceptor = _LoggingClientInterceptor() + self._logged_channel = grpc.intercept_channel( + self._grpc_channel, self._interceptor + ) + + # Wrap messages. This must be done after self._logged_channel exists + self._prep_wrapped_messages(client_info) + + @classmethod + def create_channel( + cls, + host: str = "cloudsecuritycompliance.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + **kwargs, + ) -> grpc.Channel: + """Create and return a gRPC channel object. + Args: + host (Optional[str]): The host for the channel to use. + credentials (Optional[~.Credentials]): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is mutually exclusive with credentials. This argument will be + removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + kwargs (Optional[dict]): Keyword arguments, which are passed to the + channel creation. + Returns: + grpc.Channel: A gRPC channel object. + + Raises: + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + + return grpc_helpers.create_channel( + host, + credentials=credentials, + credentials_file=credentials_file, + quota_project_id=quota_project_id, + default_scopes=cls.AUTH_SCOPES, + scopes=scopes, + default_host=cls.DEFAULT_HOST, + **kwargs, + ) + + @property + def grpc_channel(self) -> grpc.Channel: + """Return the channel designed to connect to this service.""" + return self._grpc_channel + + @property + def list_framework_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListFrameworkComplianceSummariesRequest], + monitoring.ListFrameworkComplianceSummariesResponse, + ]: + r"""Return a callable for the list framework compliance + summaries method over gRPC. + + Lists the framework compliance summary for a given + scope. + + Returns: + Callable[[~.ListFrameworkComplianceSummariesRequest], + ~.ListFrameworkComplianceSummariesResponse]: + 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_framework_compliance_summaries" not in self._stubs: + self._stubs[ + "list_framework_compliance_summaries" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/ListFrameworkComplianceSummaries", + request_serializer=monitoring.ListFrameworkComplianceSummariesRequest.serialize, + response_deserializer=monitoring.ListFrameworkComplianceSummariesResponse.deserialize, + ) + return self._stubs["list_framework_compliance_summaries"] + + @property + def list_finding_summaries( + self, + ) -> Callable[ + [monitoring.ListFindingSummariesRequest], + monitoring.ListFindingSummariesResponse, + ]: + r"""Return a callable for the list finding summaries method over gRPC. + + Lists the finding summary by category for a given + scope. + + Returns: + Callable[[~.ListFindingSummariesRequest], + ~.ListFindingSummariesResponse]: + 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_finding_summaries" not in self._stubs: + self._stubs["list_finding_summaries"] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/ListFindingSummaries", + request_serializer=monitoring.ListFindingSummariesRequest.serialize, + response_deserializer=monitoring.ListFindingSummariesResponse.deserialize, + ) + return self._stubs["list_finding_summaries"] + + @property + def fetch_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.FetchFrameworkComplianceReportRequest], + monitoring.FrameworkComplianceReport, + ]: + r"""Return a callable for the fetch framework compliance + report method over gRPC. + + Fetches the framework compliance report for a given + scope. + + Returns: + Callable[[~.FetchFrameworkComplianceReportRequest], + ~.FrameworkComplianceReport]: + 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 "fetch_framework_compliance_report" not in self._stubs: + self._stubs[ + "fetch_framework_compliance_report" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/FetchFrameworkComplianceReport", + request_serializer=monitoring.FetchFrameworkComplianceReportRequest.serialize, + response_deserializer=monitoring.FrameworkComplianceReport.deserialize, + ) + return self._stubs["fetch_framework_compliance_report"] + + @property + def list_control_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListControlComplianceSummariesRequest], + monitoring.ListControlComplianceSummariesResponse, + ]: + r"""Return a callable for the list control compliance + summaries method over gRPC. + + Lists the control compliance summary for a given + scope. + + Returns: + Callable[[~.ListControlComplianceSummariesRequest], + ~.ListControlComplianceSummariesResponse]: + 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_control_compliance_summaries" not in self._stubs: + self._stubs[ + "list_control_compliance_summaries" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/ListControlComplianceSummaries", + request_serializer=monitoring.ListControlComplianceSummariesRequest.serialize, + response_deserializer=monitoring.ListControlComplianceSummariesResponse.deserialize, + ) + return self._stubs["list_control_compliance_summaries"] + + @property + def aggregate_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.AggregateFrameworkComplianceReportRequest], + monitoring.AggregateFrameworkComplianceReportResponse, + ]: + r"""Return a callable for the aggregate framework compliance + report method over gRPC. + + Gets the aggregated compliance report over time for a + given scope. + + Returns: + Callable[[~.AggregateFrameworkComplianceReportRequest], + ~.AggregateFrameworkComplianceReportResponse]: + 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 "aggregate_framework_compliance_report" not in self._stubs: + self._stubs[ + "aggregate_framework_compliance_report" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/AggregateFrameworkComplianceReport", + request_serializer=monitoring.AggregateFrameworkComplianceReportRequest.serialize, + response_deserializer=monitoring.AggregateFrameworkComplianceReportResponse.deserialize, + ) + return self._stubs["aggregate_framework_compliance_report"] + + def close(self): + self._logged_channel.close() + + @property + def delete_operation( + self, + ) -> Callable[[operations_pb2.DeleteOperationRequest], None]: + r"""Return a callable for the delete_operation method over gRPC.""" + # 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 "delete_operation" not in self._stubs: + self._stubs["delete_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/DeleteOperation", + request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["delete_operation"] + + @property + def cancel_operation( + self, + ) -> Callable[[operations_pb2.CancelOperationRequest], None]: + r"""Return a callable for the cancel_operation method over gRPC.""" + # 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 "cancel_operation" not in self._stubs: + self._stubs["cancel_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/CancelOperation", + request_serializer=operations_pb2.CancelOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["cancel_operation"] + + @property + def get_operation( + self, + ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]: + r"""Return a callable for the get_operation method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_operation" not in self._stubs: + self._stubs["get_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/GetOperation", + request_serializer=operations_pb2.GetOperationRequest.SerializeToString, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["get_operation"] + + @property + def list_operations( + self, + ) -> Callable[ + [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse + ]: + r"""Return a callable for the list_operations method over gRPC.""" + # 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_operations" not in self._stubs: + self._stubs["list_operations"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/ListOperations", + request_serializer=operations_pb2.ListOperationsRequest.SerializeToString, + response_deserializer=operations_pb2.ListOperationsResponse.FromString, + ) + return self._stubs["list_operations"] + + @property + def list_locations( + self, + ) -> Callable[ + [locations_pb2.ListLocationsRequest], locations_pb2.ListLocationsResponse + ]: + r"""Return a callable for the list locations method over gRPC.""" + # 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_locations" not in self._stubs: + self._stubs["list_locations"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/ListLocations", + request_serializer=locations_pb2.ListLocationsRequest.SerializeToString, + response_deserializer=locations_pb2.ListLocationsResponse.FromString, + ) + return self._stubs["list_locations"] + + @property + def get_location( + self, + ) -> Callable[[locations_pb2.GetLocationRequest], locations_pb2.Location]: + r"""Return a callable for the list locations method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_location" not in self._stubs: + self._stubs["get_location"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/GetLocation", + request_serializer=locations_pb2.GetLocationRequest.SerializeToString, + response_deserializer=locations_pb2.Location.FromString, + ) + return self._stubs["get_location"] + + @property + def kind(self) -> str: + return "grpc" + + +__all__ = ("MonitoringGrpcTransport",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/grpc_asyncio.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/grpc_asyncio.py new file mode 100644 index 000000000000..a998d221f40a --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/grpc_asyncio.py @@ -0,0 +1,720 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import inspect +import json +import logging as std_logging +import pickle +from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union +import warnings + +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1, grpc_helpers_async +from google.api_core import retry_async as retries +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf.json_format import MessageToJson +import google.protobuf.message +import grpc # type: ignore +from grpc.experimental import aio # type: ignore +import proto # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.types import monitoring + +from .base import DEFAULT_CLIENT_INFO, MonitoringTransport +from .grpc import MonitoringGrpcTransport + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + + +class _LoggingClientAIOInterceptor( + grpc.aio.UnaryUnaryClientInterceptor +): # pragma: NO COVER + async def intercept_unary_unary(self, continuation, client_call_details, request): + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ) + if logging_enabled: # pragma: NO COVER + request_metadata = client_call_details.metadata + if isinstance(request, proto.Message): + request_payload = type(request).to_json(request) + elif isinstance(request, google.protobuf.message.Message): + request_payload = MessageToJson(request) + else: + request_payload = f"{type(request).__name__}: {pickle.dumps(request)}" + + request_metadata = { + key: value.decode("utf-8") if isinstance(value, bytes) else value + for key, value in request_metadata + } + grpc_request = { + "payload": request_payload, + "requestMethod": "grpc", + "metadata": dict(request_metadata), + } + _LOGGER.debug( + f"Sending request for {client_call_details.method}", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": str(client_call_details.method), + "request": grpc_request, + "metadata": grpc_request["metadata"], + }, + ) + response = await continuation(client_call_details, request) + if logging_enabled: # pragma: NO COVER + response_metadata = await response.trailing_metadata() + # Convert gRPC metadata `` to list of tuples + metadata = ( + dict([(k, str(v)) for k, v in response_metadata]) + if response_metadata + else None + ) + result = await response + if isinstance(result, proto.Message): + response_payload = type(result).to_json(result) + elif isinstance(result, google.protobuf.message.Message): + response_payload = MessageToJson(result) + else: + response_payload = f"{type(result).__name__}: {pickle.dumps(result)}" + grpc_response = { + "payload": response_payload, + "metadata": metadata, + "status": "OK", + } + _LOGGER.debug( + f"Received response to rpc {client_call_details.method}.", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": str(client_call_details.method), + "response": grpc_response, + "metadata": grpc_response["metadata"], + }, + ) + return response + + +class MonitoringGrpcAsyncIOTransport(MonitoringTransport): + """gRPC AsyncIO backend transport for Monitoring. + + Service describing handlers for resources + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends protocol buffers over the wire using gRPC (which is built on + top of HTTP/2); the ``grpcio`` package must be installed. + """ + + _grpc_channel: aio.Channel + _stubs: Dict[str, Callable] = {} + + @classmethod + def create_channel( + cls, + host: str = "cloudsecuritycompliance.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + **kwargs, + ) -> aio.Channel: + """Create and return a gRPC AsyncIO channel object. + Args: + host (Optional[str]): The host for the channel to use. + credentials (Optional[~.Credentials]): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. This argument will be + removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + kwargs (Optional[dict]): Keyword arguments, which are passed to the + channel creation. + Returns: + aio.Channel: A gRPC AsyncIO channel object. + """ + + return grpc_helpers_async.create_channel( + host, + credentials=credentials, + credentials_file=credentials_file, + quota_project_id=quota_project_id, + default_scopes=cls.AUTH_SCOPES, + scopes=scopes, + default_host=cls.DEFAULT_HOST, + **kwargs, + ) + + def __init__( + self, + *, + host: str = "cloudsecuritycompliance.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + channel: Optional[Union[aio.Channel, Callable[..., aio.Channel]]] = None, + api_mtls_endpoint: Optional[str] = None, + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'cloudsecuritycompliance.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is ignored if a ``channel`` instance is provided. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if a ``channel`` instance is provided. + This argument will be removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + channel (Optional[Union[aio.Channel, Callable[..., aio.Channel]]]): + A ``Channel`` instance through which to make calls, or a Callable + that constructs and returns one. If set to None, ``self.create_channel`` + is used to create the channel. If a Callable is given, it will be called + with the same arguments as used in ``self.create_channel``. + api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint. + If provided, it overrides the ``host`` argument and tries to create + a mutual TLS channel with client SSL credentials from + ``client_cert_source`` or application default SSL credentials. + client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): + Deprecated. A callback to provide client SSL certificate bytes and + private key bytes, both in PEM format. It is ignored if + ``api_mtls_endpoint`` is None. + ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials + for the grpc channel. It is ignored if a ``channel`` instance is provided. + client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]): + A callback to provide client certificate bytes and private key bytes, + both in PEM format. It is used to configure a mutual TLS channel. It is + ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + + Raises: + google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport + creation failed for any reason. + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + self._grpc_channel = None + self._ssl_channel_credentials = ssl_channel_credentials + self._stubs: Dict[str, Callable] = {} + + if api_mtls_endpoint: + warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning) + if client_cert_source: + warnings.warn("client_cert_source is deprecated", DeprecationWarning) + + if isinstance(channel, aio.Channel): + # Ignore credentials if a channel was passed. + credentials = None + self._ignore_credentials = True + # If a channel was explicitly provided, set it. + self._grpc_channel = channel + self._ssl_channel_credentials = None + else: + if api_mtls_endpoint: + host = api_mtls_endpoint + + # Create SSL credentials with client_cert_source or application + # default SSL credentials. + if client_cert_source: + cert, key = client_cert_source() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + else: + self._ssl_channel_credentials = SslCredentials().ssl_credentials + + else: + if client_cert_source_for_mtls and not ssl_channel_credentials: + cert, key = client_cert_source_for_mtls() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + + # The base transport sets the host, credentials and scopes + super().__init__( + host=host, + credentials=credentials, + credentials_file=credentials_file, + scopes=scopes, + quota_project_id=quota_project_id, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + + if not self._grpc_channel: + # initialize with the provided callable or the default channel + channel_init = channel or type(self).create_channel + self._grpc_channel = channel_init( + self._host, + # use the credentials which are saved + credentials=self._credentials, + # Set ``credentials_file`` to ``None`` here as + # the credentials that we saved earlier should be used. + credentials_file=None, + scopes=self._scopes, + ssl_credentials=self._ssl_channel_credentials, + quota_project_id=quota_project_id, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + self._interceptor = _LoggingClientAIOInterceptor() + self._grpc_channel._unary_unary_interceptors.append(self._interceptor) + self._logged_channel = self._grpc_channel + self._wrap_with_kind = ( + "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters + ) + # Wrap messages. This must be done after self._logged_channel exists + self._prep_wrapped_messages(client_info) + + @property + def grpc_channel(self) -> aio.Channel: + """Create the channel designed to connect to this service. + + This property caches on the instance; repeated calls return + the same channel. + """ + # Return the channel from cache. + return self._grpc_channel + + @property + def list_framework_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListFrameworkComplianceSummariesRequest], + Awaitable[monitoring.ListFrameworkComplianceSummariesResponse], + ]: + r"""Return a callable for the list framework compliance + summaries method over gRPC. + + Lists the framework compliance summary for a given + scope. + + Returns: + Callable[[~.ListFrameworkComplianceSummariesRequest], + Awaitable[~.ListFrameworkComplianceSummariesResponse]]: + 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_framework_compliance_summaries" not in self._stubs: + self._stubs[ + "list_framework_compliance_summaries" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/ListFrameworkComplianceSummaries", + request_serializer=monitoring.ListFrameworkComplianceSummariesRequest.serialize, + response_deserializer=monitoring.ListFrameworkComplianceSummariesResponse.deserialize, + ) + return self._stubs["list_framework_compliance_summaries"] + + @property + def list_finding_summaries( + self, + ) -> Callable[ + [monitoring.ListFindingSummariesRequest], + Awaitable[monitoring.ListFindingSummariesResponse], + ]: + r"""Return a callable for the list finding summaries method over gRPC. + + Lists the finding summary by category for a given + scope. + + Returns: + Callable[[~.ListFindingSummariesRequest], + Awaitable[~.ListFindingSummariesResponse]]: + 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_finding_summaries" not in self._stubs: + self._stubs["list_finding_summaries"] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/ListFindingSummaries", + request_serializer=monitoring.ListFindingSummariesRequest.serialize, + response_deserializer=monitoring.ListFindingSummariesResponse.deserialize, + ) + return self._stubs["list_finding_summaries"] + + @property + def fetch_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.FetchFrameworkComplianceReportRequest], + Awaitable[monitoring.FrameworkComplianceReport], + ]: + r"""Return a callable for the fetch framework compliance + report method over gRPC. + + Fetches the framework compliance report for a given + scope. + + Returns: + Callable[[~.FetchFrameworkComplianceReportRequest], + Awaitable[~.FrameworkComplianceReport]]: + 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 "fetch_framework_compliance_report" not in self._stubs: + self._stubs[ + "fetch_framework_compliance_report" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/FetchFrameworkComplianceReport", + request_serializer=monitoring.FetchFrameworkComplianceReportRequest.serialize, + response_deserializer=monitoring.FrameworkComplianceReport.deserialize, + ) + return self._stubs["fetch_framework_compliance_report"] + + @property + def list_control_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListControlComplianceSummariesRequest], + Awaitable[monitoring.ListControlComplianceSummariesResponse], + ]: + r"""Return a callable for the list control compliance + summaries method over gRPC. + + Lists the control compliance summary for a given + scope. + + Returns: + Callable[[~.ListControlComplianceSummariesRequest], + Awaitable[~.ListControlComplianceSummariesResponse]]: + 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_control_compliance_summaries" not in self._stubs: + self._stubs[ + "list_control_compliance_summaries" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/ListControlComplianceSummaries", + request_serializer=monitoring.ListControlComplianceSummariesRequest.serialize, + response_deserializer=monitoring.ListControlComplianceSummariesResponse.deserialize, + ) + return self._stubs["list_control_compliance_summaries"] + + @property + def aggregate_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.AggregateFrameworkComplianceReportRequest], + Awaitable[monitoring.AggregateFrameworkComplianceReportResponse], + ]: + r"""Return a callable for the aggregate framework compliance + report method over gRPC. + + Gets the aggregated compliance report over time for a + given scope. + + Returns: + Callable[[~.AggregateFrameworkComplianceReportRequest], + Awaitable[~.AggregateFrameworkComplianceReportResponse]]: + 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 "aggregate_framework_compliance_report" not in self._stubs: + self._stubs[ + "aggregate_framework_compliance_report" + ] = self._logged_channel.unary_unary( + "/google.cloud.cloudsecuritycompliance.v1.Monitoring/AggregateFrameworkComplianceReport", + request_serializer=monitoring.AggregateFrameworkComplianceReportRequest.serialize, + response_deserializer=monitoring.AggregateFrameworkComplianceReportResponse.deserialize, + ) + return self._stubs["aggregate_framework_compliance_report"] + + def _prep_wrapped_messages(self, client_info): + """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" + self._wrapped_methods = { + self.list_framework_compliance_summaries: self._wrap_method( + self.list_framework_compliance_summaries, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.list_finding_summaries: self._wrap_method( + self.list_finding_summaries, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.fetch_framework_compliance_report: self._wrap_method( + self.fetch_framework_compliance_report, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.list_control_compliance_summaries: self._wrap_method( + self.list_control_compliance_summaries, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.aggregate_framework_compliance_report: self._wrap_method( + self.aggregate_framework_compliance_report, + default_retry=retries.AsyncRetry( + initial=1.0, + maximum=10.0, + multiplier=1.3, + predicate=retries.if_exception_type( + core_exceptions.ServiceUnavailable, + ), + deadline=60.0, + ), + default_timeout=60.0, + client_info=client_info, + ), + self.get_location: self._wrap_method( + self.get_location, + default_timeout=None, + client_info=client_info, + ), + self.list_locations: self._wrap_method( + self.list_locations, + default_timeout=None, + client_info=client_info, + ), + self.cancel_operation: self._wrap_method( + self.cancel_operation, + default_timeout=None, + client_info=client_info, + ), + self.delete_operation: self._wrap_method( + self.delete_operation, + default_timeout=None, + client_info=client_info, + ), + self.get_operation: self._wrap_method( + self.get_operation, + default_timeout=None, + client_info=client_info, + ), + self.list_operations: self._wrap_method( + self.list_operations, + default_timeout=None, + client_info=client_info, + ), + } + + def _wrap_method(self, func, *args, **kwargs): + if self._wrap_with_kind: # pragma: NO COVER + kwargs["kind"] = self.kind + return gapic_v1.method_async.wrap_method(func, *args, **kwargs) + + def close(self): + return self._logged_channel.close() + + @property + def kind(self) -> str: + return "grpc_asyncio" + + @property + def delete_operation( + self, + ) -> Callable[[operations_pb2.DeleteOperationRequest], None]: + r"""Return a callable for the delete_operation method over gRPC.""" + # 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 "delete_operation" not in self._stubs: + self._stubs["delete_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/DeleteOperation", + request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["delete_operation"] + + @property + def cancel_operation( + self, + ) -> Callable[[operations_pb2.CancelOperationRequest], None]: + r"""Return a callable for the cancel_operation method over gRPC.""" + # 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 "cancel_operation" not in self._stubs: + self._stubs["cancel_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/CancelOperation", + request_serializer=operations_pb2.CancelOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["cancel_operation"] + + @property + def get_operation( + self, + ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]: + r"""Return a callable for the get_operation method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_operation" not in self._stubs: + self._stubs["get_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/GetOperation", + request_serializer=operations_pb2.GetOperationRequest.SerializeToString, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["get_operation"] + + @property + def list_operations( + self, + ) -> Callable[ + [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse + ]: + r"""Return a callable for the list_operations method over gRPC.""" + # 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_operations" not in self._stubs: + self._stubs["list_operations"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/ListOperations", + request_serializer=operations_pb2.ListOperationsRequest.SerializeToString, + response_deserializer=operations_pb2.ListOperationsResponse.FromString, + ) + return self._stubs["list_operations"] + + @property + def list_locations( + self, + ) -> Callable[ + [locations_pb2.ListLocationsRequest], locations_pb2.ListLocationsResponse + ]: + r"""Return a callable for the list locations method over gRPC.""" + # 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_locations" not in self._stubs: + self._stubs["list_locations"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/ListLocations", + request_serializer=locations_pb2.ListLocationsRequest.SerializeToString, + response_deserializer=locations_pb2.ListLocationsResponse.FromString, + ) + return self._stubs["list_locations"] + + @property + def get_location( + self, + ) -> Callable[[locations_pb2.GetLocationRequest], locations_pb2.Location]: + r"""Return a callable for the list locations method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_location" not in self._stubs: + self._stubs["get_location"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/GetLocation", + request_serializer=locations_pb2.GetLocationRequest.SerializeToString, + response_deserializer=locations_pb2.Location.FromString, + ) + return self._stubs["get_location"] + + +__all__ = ("MonitoringGrpcAsyncIOTransport",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/rest.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/rest.py new file mode 100644 index 000000000000..bc744a7c3e0b --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/rest.py @@ -0,0 +1,2275 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import dataclasses +import json # type: ignore +import logging +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union +import warnings + +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1, rest_helpers, rest_streaming +from google.api_core import retry as retries +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.requests import AuthorizedSession # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +import google.protobuf +from google.protobuf import json_format +from requests import __version__ as requests_version + +from google.cloud.cloudsecuritycompliance_v1.types import monitoring + +from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO +from .rest_base import _BaseMonitoringRestTransport + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object, None] # type: ignore + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = logging.getLogger(__name__) + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version, + grpc_version=None, + rest_version=f"requests@{requests_version}", +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + + +class MonitoringRestInterceptor: + """Interceptor for Monitoring. + + Interceptors are used to manipulate requests, request metadata, and responses + in arbitrary ways. + Example use cases include: + * Logging + * Verifying requests according to service or custom semantics + * Stripping extraneous information from responses + + These use cases and more can be enabled by injecting an + instance of a custom subclass when constructing the MonitoringRestTransport. + + .. code-block:: python + class MyCustomMonitoringInterceptor(MonitoringRestInterceptor): + def pre_aggregate_framework_compliance_report(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_aggregate_framework_compliance_report(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_fetch_framework_compliance_report(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_fetch_framework_compliance_report(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_list_control_compliance_summaries(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_control_compliance_summaries(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_list_finding_summaries(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_finding_summaries(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_list_framework_compliance_summaries(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_framework_compliance_summaries(self, response): + logging.log(f"Received response: {response}") + return response + + transport = MonitoringRestTransport(interceptor=MyCustomMonitoringInterceptor()) + client = MonitoringClient(transport=transport) + + + """ + + def pre_aggregate_framework_compliance_report( + self, + request: monitoring.AggregateFrameworkComplianceReportRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.AggregateFrameworkComplianceReportRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for aggregate_framework_compliance_report + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_aggregate_framework_compliance_report( + self, response: monitoring.AggregateFrameworkComplianceReportResponse + ) -> monitoring.AggregateFrameworkComplianceReportResponse: + """Post-rpc interceptor for aggregate_framework_compliance_report + + DEPRECATED. Please use the `post_aggregate_framework_compliance_report_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. This `post_aggregate_framework_compliance_report` interceptor runs + before the `post_aggregate_framework_compliance_report_with_metadata` interceptor. + """ + return response + + def post_aggregate_framework_compliance_report_with_metadata( + self, + response: monitoring.AggregateFrameworkComplianceReportResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.AggregateFrameworkComplianceReportResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for aggregate_framework_compliance_report + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the Monitoring server but before it is returned to user code. + + We recommend only using this `post_aggregate_framework_compliance_report_with_metadata` + interceptor in new development instead of the `post_aggregate_framework_compliance_report` interceptor. + When both interceptors are used, this `post_aggregate_framework_compliance_report_with_metadata` interceptor runs after the + `post_aggregate_framework_compliance_report` interceptor. The (possibly modified) response returned by + `post_aggregate_framework_compliance_report` will be passed to + `post_aggregate_framework_compliance_report_with_metadata`. + """ + return response, metadata + + def pre_fetch_framework_compliance_report( + self, + request: monitoring.FetchFrameworkComplianceReportRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.FetchFrameworkComplianceReportRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for fetch_framework_compliance_report + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_fetch_framework_compliance_report( + self, response: monitoring.FrameworkComplianceReport + ) -> monitoring.FrameworkComplianceReport: + """Post-rpc interceptor for fetch_framework_compliance_report + + DEPRECATED. Please use the `post_fetch_framework_compliance_report_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. This `post_fetch_framework_compliance_report` interceptor runs + before the `post_fetch_framework_compliance_report_with_metadata` interceptor. + """ + return response + + def post_fetch_framework_compliance_report_with_metadata( + self, + response: monitoring.FrameworkComplianceReport, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.FrameworkComplianceReport, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for fetch_framework_compliance_report + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the Monitoring server but before it is returned to user code. + + We recommend only using this `post_fetch_framework_compliance_report_with_metadata` + interceptor in new development instead of the `post_fetch_framework_compliance_report` interceptor. + When both interceptors are used, this `post_fetch_framework_compliance_report_with_metadata` interceptor runs after the + `post_fetch_framework_compliance_report` interceptor. The (possibly modified) response returned by + `post_fetch_framework_compliance_report` will be passed to + `post_fetch_framework_compliance_report_with_metadata`. + """ + return response, metadata + + def pre_list_control_compliance_summaries( + self, + request: monitoring.ListControlComplianceSummariesRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.ListControlComplianceSummariesRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for list_control_compliance_summaries + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_list_control_compliance_summaries( + self, response: monitoring.ListControlComplianceSummariesResponse + ) -> monitoring.ListControlComplianceSummariesResponse: + """Post-rpc interceptor for list_control_compliance_summaries + + DEPRECATED. Please use the `post_list_control_compliance_summaries_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. This `post_list_control_compliance_summaries` interceptor runs + before the `post_list_control_compliance_summaries_with_metadata` interceptor. + """ + return response + + def post_list_control_compliance_summaries_with_metadata( + self, + response: monitoring.ListControlComplianceSummariesResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.ListControlComplianceSummariesResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for list_control_compliance_summaries + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the Monitoring server but before it is returned to user code. + + We recommend only using this `post_list_control_compliance_summaries_with_metadata` + interceptor in new development instead of the `post_list_control_compliance_summaries` interceptor. + When both interceptors are used, this `post_list_control_compliance_summaries_with_metadata` interceptor runs after the + `post_list_control_compliance_summaries` interceptor. The (possibly modified) response returned by + `post_list_control_compliance_summaries` will be passed to + `post_list_control_compliance_summaries_with_metadata`. + """ + return response, metadata + + def pre_list_finding_summaries( + self, + request: monitoring.ListFindingSummariesRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.ListFindingSummariesRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for list_finding_summaries + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_list_finding_summaries( + self, response: monitoring.ListFindingSummariesResponse + ) -> monitoring.ListFindingSummariesResponse: + """Post-rpc interceptor for list_finding_summaries + + DEPRECATED. Please use the `post_list_finding_summaries_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. This `post_list_finding_summaries` interceptor runs + before the `post_list_finding_summaries_with_metadata` interceptor. + """ + return response + + def post_list_finding_summaries_with_metadata( + self, + response: monitoring.ListFindingSummariesResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.ListFindingSummariesResponse, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for list_finding_summaries + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the Monitoring server but before it is returned to user code. + + We recommend only using this `post_list_finding_summaries_with_metadata` + interceptor in new development instead of the `post_list_finding_summaries` interceptor. + When both interceptors are used, this `post_list_finding_summaries_with_metadata` interceptor runs after the + `post_list_finding_summaries` interceptor. The (possibly modified) response returned by + `post_list_finding_summaries` will be passed to + `post_list_finding_summaries_with_metadata`. + """ + return response, metadata + + def pre_list_framework_compliance_summaries( + self, + request: monitoring.ListFrameworkComplianceSummariesRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.ListFrameworkComplianceSummariesRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for list_framework_compliance_summaries + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_list_framework_compliance_summaries( + self, response: monitoring.ListFrameworkComplianceSummariesResponse + ) -> monitoring.ListFrameworkComplianceSummariesResponse: + """Post-rpc interceptor for list_framework_compliance_summaries + + DEPRECATED. Please use the `post_list_framework_compliance_summaries_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. This `post_list_framework_compliance_summaries` interceptor runs + before the `post_list_framework_compliance_summaries_with_metadata` interceptor. + """ + return response + + def post_list_framework_compliance_summaries_with_metadata( + self, + response: monitoring.ListFrameworkComplianceSummariesResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + monitoring.ListFrameworkComplianceSummariesResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for list_framework_compliance_summaries + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the Monitoring server but before it is returned to user code. + + We recommend only using this `post_list_framework_compliance_summaries_with_metadata` + interceptor in new development instead of the `post_list_framework_compliance_summaries` interceptor. + When both interceptors are used, this `post_list_framework_compliance_summaries_with_metadata` interceptor runs after the + `post_list_framework_compliance_summaries` interceptor. The (possibly modified) response returned by + `post_list_framework_compliance_summaries` will be passed to + `post_list_framework_compliance_summaries_with_metadata`. + """ + return response, metadata + + def pre_get_location( + self, + request: locations_pb2.GetLocationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + locations_pb2.GetLocationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_location + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_get_location( + self, response: locations_pb2.Location + ) -> locations_pb2.Location: + """Post-rpc interceptor for get_location + + Override in a subclass to manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. + """ + return response + + def pre_list_locations( + self, + request: locations_pb2.ListLocationsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + locations_pb2.ListLocationsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for list_locations + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_list_locations( + self, response: locations_pb2.ListLocationsResponse + ) -> locations_pb2.ListLocationsResponse: + """Post-rpc interceptor for list_locations + + Override in a subclass to manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. + """ + return response + + def pre_cancel_operation( + self, + request: operations_pb2.CancelOperationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.CancelOperationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for cancel_operation + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_cancel_operation(self, response: None) -> None: + """Post-rpc interceptor for cancel_operation + + Override in a subclass to manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. + """ + return response + + def pre_delete_operation( + self, + request: operations_pb2.DeleteOperationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.DeleteOperationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for delete_operation + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_delete_operation(self, response: None) -> None: + """Post-rpc interceptor for delete_operation + + Override in a subclass to manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. + """ + return response + + def pre_get_operation( + self, + request: operations_pb2.GetOperationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.GetOperationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_operation + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_get_operation( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for get_operation + + Override in a subclass to manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. + """ + return response + + def pre_list_operations( + self, + request: operations_pb2.ListOperationsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.ListOperationsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for list_operations + + Override in a subclass to manipulate the request or metadata + before they are sent to the Monitoring server. + """ + return request, metadata + + def post_list_operations( + self, response: operations_pb2.ListOperationsResponse + ) -> operations_pb2.ListOperationsResponse: + """Post-rpc interceptor for list_operations + + Override in a subclass to manipulate the response + after it is returned by the Monitoring server but before + it is returned to user code. + """ + return response + + +@dataclasses.dataclass +class MonitoringRestStub: + _session: AuthorizedSession + _host: str + _interceptor: MonitoringRestInterceptor + + +class MonitoringRestTransport(_BaseMonitoringRestTransport): + """REST backend synchronous transport for Monitoring. + + Service describing handlers for resources + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends JSON representations of protocol buffers over HTTP/1.1 + """ + + def __init__( + self, + *, + host: str = "cloudsecuritycompliance.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + url_scheme: str = "https", + interceptor: Optional[MonitoringRestInterceptor] = None, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'cloudsecuritycompliance.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if ``channel`` is provided. This argument will be + removed in the next major version of this library. + scopes (Optional(Sequence[str])): A list of scopes. This argument is + ignored if ``channel`` is provided. + client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client + certificate to configure mutual TLS HTTP channel. It is ignored + if ``channel`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you are developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + url_scheme: the protocol scheme for the API endpoint. Normally + "https", but for testing or local servers, + "http" can be specified. + """ + # Run the base constructor + # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc. + # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the + # credentials object + super().__init__( + host=host, + credentials=credentials, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + url_scheme=url_scheme, + api_audience=api_audience, + ) + self._session = AuthorizedSession( + self._credentials, default_host=self.DEFAULT_HOST + ) + if client_cert_source_for_mtls: + self._session.configure_mtls_channel(client_cert_source_for_mtls) + self._interceptor = interceptor or MonitoringRestInterceptor() + self._prep_wrapped_messages(client_info) + + class _AggregateFrameworkComplianceReport( + _BaseMonitoringRestTransport._BaseAggregateFrameworkComplianceReport, + MonitoringRestStub, + ): + def __hash__(self): + return hash("MonitoringRestTransport.AggregateFrameworkComplianceReport") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: monitoring.AggregateFrameworkComplianceReportRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.AggregateFrameworkComplianceReportResponse: + r"""Call the aggregate framework + compliance report method over HTTP. + + Args: + request (~.monitoring.AggregateFrameworkComplianceReportRequest): + The request object. The request message for + [AggregateFrameworkComplianceReport][]. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.monitoring.AggregateFrameworkComplianceReportResponse: + The response message for + [AggregateFrameworkComplianceReport][]. + + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseAggregateFrameworkComplianceReport._get_http_options() + ) + + ( + request, + metadata, + ) = self._interceptor.pre_aggregate_framework_compliance_report( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseAggregateFrameworkComplianceReport._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseAggregateFrameworkComplianceReport._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.AggregateFrameworkComplianceReport", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "AggregateFrameworkComplianceReport", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._AggregateFrameworkComplianceReport._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = monitoring.AggregateFrameworkComplianceReportResponse() + pb_resp = monitoring.AggregateFrameworkComplianceReportResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_aggregate_framework_compliance_report(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_aggregate_framework_compliance_report_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + monitoring.AggregateFrameworkComplianceReportResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.aggregate_framework_compliance_report", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "AggregateFrameworkComplianceReport", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _FetchFrameworkComplianceReport( + _BaseMonitoringRestTransport._BaseFetchFrameworkComplianceReport, + MonitoringRestStub, + ): + def __hash__(self): + return hash("MonitoringRestTransport.FetchFrameworkComplianceReport") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: monitoring.FetchFrameworkComplianceReportRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.FrameworkComplianceReport: + r"""Call the fetch framework + compliance report method over HTTP. + + Args: + request (~.monitoring.FetchFrameworkComplianceReportRequest): + The request object. The request message for + [FetchFrameworkComplianceReport][]. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.monitoring.FrameworkComplianceReport: + The response message for + [GetFrameworkComplianceReport][]. + + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseFetchFrameworkComplianceReport._get_http_options() + ) + + request, metadata = self._interceptor.pre_fetch_framework_compliance_report( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseFetchFrameworkComplianceReport._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseFetchFrameworkComplianceReport._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.FetchFrameworkComplianceReport", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "FetchFrameworkComplianceReport", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + MonitoringRestTransport._FetchFrameworkComplianceReport._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # 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 = monitoring.FrameworkComplianceReport() + pb_resp = monitoring.FrameworkComplianceReport.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_fetch_framework_compliance_report(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_fetch_framework_compliance_report_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = monitoring.FrameworkComplianceReport.to_json( + response + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.fetch_framework_compliance_report", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "FetchFrameworkComplianceReport", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ListControlComplianceSummaries( + _BaseMonitoringRestTransport._BaseListControlComplianceSummaries, + MonitoringRestStub, + ): + def __hash__(self): + return hash("MonitoringRestTransport.ListControlComplianceSummaries") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: monitoring.ListControlComplianceSummariesRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.ListControlComplianceSummariesResponse: + r"""Call the list control compliance + summaries method over HTTP. + + Args: + request (~.monitoring.ListControlComplianceSummariesRequest): + The request object. The request message for + [ListControlComplianceSummaries][]. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.monitoring.ListControlComplianceSummariesResponse: + The response message for + [ListControlComplianceSummaries][]. + + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseListControlComplianceSummaries._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_control_compliance_summaries( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseListControlComplianceSummaries._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseListControlComplianceSummaries._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.ListControlComplianceSummaries", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListControlComplianceSummaries", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + MonitoringRestTransport._ListControlComplianceSummaries._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # 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 = monitoring.ListControlComplianceSummariesResponse() + pb_resp = monitoring.ListControlComplianceSummariesResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_control_compliance_summaries(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_list_control_compliance_summaries_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + monitoring.ListControlComplianceSummariesResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.list_control_compliance_summaries", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListControlComplianceSummaries", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ListFindingSummaries( + _BaseMonitoringRestTransport._BaseListFindingSummaries, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.ListFindingSummaries") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: monitoring.ListFindingSummariesRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.ListFindingSummariesResponse: + r"""Call the list finding summaries method over HTTP. + + Args: + request (~.monitoring.ListFindingSummariesRequest): + The request object. The request message for [ListFindingSummaries][]. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.monitoring.ListFindingSummariesResponse: + The response message for [ListFindingSummaries][]. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseListFindingSummaries._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_finding_summaries( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseListFindingSummaries._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseListFindingSummaries._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.ListFindingSummaries", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListFindingSummaries", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._ListFindingSummaries._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = monitoring.ListFindingSummariesResponse() + pb_resp = monitoring.ListFindingSummariesResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_finding_summaries(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_list_finding_summaries_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = monitoring.ListFindingSummariesResponse.to_json( + response + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.list_finding_summaries", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListFindingSummaries", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ListFrameworkComplianceSummaries( + _BaseMonitoringRestTransport._BaseListFrameworkComplianceSummaries, + MonitoringRestStub, + ): + def __hash__(self): + return hash("MonitoringRestTransport.ListFrameworkComplianceSummaries") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: monitoring.ListFrameworkComplianceSummariesRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> monitoring.ListFrameworkComplianceSummariesResponse: + r"""Call the list framework compliance + summaries method over HTTP. + + Args: + request (~.monitoring.ListFrameworkComplianceSummariesRequest): + The request object. The request message for + [ListFrameworkComplianceSummariesRequest][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesRequest]. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.monitoring.ListFrameworkComplianceSummariesResponse: + The response message for + [ListFrameworkComplianceSummariesResponse][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesResponse]. + + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseListFrameworkComplianceSummaries._get_http_options() + ) + + ( + request, + metadata, + ) = self._interceptor.pre_list_framework_compliance_summaries( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseListFrameworkComplianceSummaries._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseListFrameworkComplianceSummaries._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.ListFrameworkComplianceSummaries", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListFrameworkComplianceSummaries", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + MonitoringRestTransport._ListFrameworkComplianceSummaries._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # 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 = monitoring.ListFrameworkComplianceSummariesResponse() + pb_resp = monitoring.ListFrameworkComplianceSummariesResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_framework_compliance_summaries(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_list_framework_compliance_summaries_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + monitoring.ListFrameworkComplianceSummariesResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.list_framework_compliance_summaries", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListFrameworkComplianceSummaries", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + @property + def aggregate_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.AggregateFrameworkComplianceReportRequest], + monitoring.AggregateFrameworkComplianceReportResponse, + ]: + # 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._AggregateFrameworkComplianceReport(self._session, self._host, self._interceptor) # type: ignore + + @property + def fetch_framework_compliance_report( + self, + ) -> Callable[ + [monitoring.FetchFrameworkComplianceReportRequest], + monitoring.FrameworkComplianceReport, + ]: + # 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._FetchFrameworkComplianceReport(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_control_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListControlComplianceSummariesRequest], + monitoring.ListControlComplianceSummariesResponse, + ]: + # 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._ListControlComplianceSummaries(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_finding_summaries( + self, + ) -> Callable[ + [monitoring.ListFindingSummariesRequest], + monitoring.ListFindingSummariesResponse, + ]: + # 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._ListFindingSummaries(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_framework_compliance_summaries( + self, + ) -> Callable[ + [monitoring.ListFrameworkComplianceSummariesRequest], + monitoring.ListFrameworkComplianceSummariesResponse, + ]: + # 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._ListFrameworkComplianceSummaries(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_location(self): + return self._GetLocation(self._session, self._host, self._interceptor) # type: ignore + + class _GetLocation( + _BaseMonitoringRestTransport._BaseGetLocation, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.GetLocation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: locations_pb2.GetLocationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.Location: + r"""Call the get location method over HTTP. + + Args: + request (locations_pb2.GetLocationRequest): + The request object for GetLocation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + locations_pb2.Location: Response from GetLocation method. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseGetLocation._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_location(request, metadata) + transcoded_request = ( + _BaseMonitoringRestTransport._BaseGetLocation._get_transcoded_request( + http_options, request + ) + ) + + # Jsonify the query params + query_params = ( + _BaseMonitoringRestTransport._BaseGetLocation._get_query_params_json( + transcoded_request + ) + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.GetLocation", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "GetLocation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._GetLocation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = locations_pb2.Location() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_get_location(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.GetLocation", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "GetLocation", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def list_locations(self): + return self._ListLocations(self._session, self._host, self._interceptor) # type: ignore + + class _ListLocations( + _BaseMonitoringRestTransport._BaseListLocations, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.ListLocations") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: locations_pb2.ListLocationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.ListLocationsResponse: + r"""Call the list locations method over HTTP. + + Args: + request (locations_pb2.ListLocationsRequest): + The request object for ListLocations 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + locations_pb2.ListLocationsResponse: Response from ListLocations method. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseListLocations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_locations(request, metadata) + transcoded_request = ( + _BaseMonitoringRestTransport._BaseListLocations._get_transcoded_request( + http_options, request + ) + ) + + # Jsonify the query params + query_params = ( + _BaseMonitoringRestTransport._BaseListLocations._get_query_params_json( + transcoded_request + ) + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.ListLocations", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListLocations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._ListLocations._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = locations_pb2.ListLocationsResponse() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_list_locations(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.ListLocations", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListLocations", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def cancel_operation(self): + return self._CancelOperation(self._session, self._host, self._interceptor) # type: ignore + + class _CancelOperation( + _BaseMonitoringRestTransport._BaseCancelOperation, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.CancelOperation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: operations_pb2.CancelOperationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Call the cancel operation method over HTTP. + + Args: + request (operations_pb2.CancelOperationRequest): + The request object for CancelOperation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseCancelOperation._get_http_options() + ) + + request, metadata = self._interceptor.pre_cancel_operation( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseCancelOperation._get_transcoded_request( + http_options, request + ) + + body = _BaseMonitoringRestTransport._BaseCancelOperation._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseCancelOperation._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.CancelOperation", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "CancelOperation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._CancelOperation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # 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 self._interceptor.post_cancel_operation(None) + + @property + def delete_operation(self): + return self._DeleteOperation(self._session, self._host, self._interceptor) # type: ignore + + class _DeleteOperation( + _BaseMonitoringRestTransport._BaseDeleteOperation, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.DeleteOperation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: operations_pb2.DeleteOperationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Call the delete operation method over HTTP. + + Args: + request (operations_pb2.DeleteOperationRequest): + The request object for DeleteOperation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseDeleteOperation._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_operation( + request, metadata + ) + transcoded_request = _BaseMonitoringRestTransport._BaseDeleteOperation._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseMonitoringRestTransport._BaseDeleteOperation._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.DeleteOperation", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "DeleteOperation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._DeleteOperation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 self._interceptor.post_delete_operation(None) + + @property + def get_operation(self): + return self._GetOperation(self._session, self._host, self._interceptor) # type: ignore + + class _GetOperation( + _BaseMonitoringRestTransport._BaseGetOperation, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.GetOperation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: operations_pb2.GetOperationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Call the get operation method over HTTP. + + Args: + request (operations_pb2.GetOperationRequest): + The request object for GetOperation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + operations_pb2.Operation: Response from GetOperation method. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseGetOperation._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_operation(request, metadata) + transcoded_request = ( + _BaseMonitoringRestTransport._BaseGetOperation._get_transcoded_request( + http_options, request + ) + ) + + # Jsonify the query params + query_params = ( + _BaseMonitoringRestTransport._BaseGetOperation._get_query_params_json( + transcoded_request + ) + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.GetOperation", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "GetOperation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._GetOperation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = operations_pb2.Operation() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_get_operation(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.GetOperation", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "GetOperation", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def list_operations(self): + return self._ListOperations(self._session, self._host, self._interceptor) # type: ignore + + class _ListOperations( + _BaseMonitoringRestTransport._BaseListOperations, MonitoringRestStub + ): + def __hash__(self): + return hash("MonitoringRestTransport.ListOperations") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: operations_pb2.ListOperationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.ListOperationsResponse: + r"""Call the list operations method over HTTP. + + Args: + request (operations_pb2.ListOperationsRequest): + The request object for ListOperations 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + operations_pb2.ListOperationsResponse: Response from ListOperations method. + """ + + http_options = ( + _BaseMonitoringRestTransport._BaseListOperations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_operations(request, metadata) + transcoded_request = _BaseMonitoringRestTransport._BaseListOperations._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = ( + _BaseMonitoringRestTransport._BaseListOperations._get_query_params_json( + transcoded_request + ) + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.cloudsecuritycompliance_v1.MonitoringClient.ListOperations", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListOperations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = MonitoringRestTransport._ListOperations._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = operations_pb2.ListOperationsResponse() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_list_operations(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.ListOperations", + extra={ + "serviceName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "rpcName": "ListOperations", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def kind(self) -> str: + return "rest" + + def close(self): + self._session.close() + + +__all__ = ("MonitoringRestTransport",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/rest_base.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/rest_base.py new file mode 100644 index 000000000000..e20fb3e2cb9b --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/services/monitoring/transports/rest_base.py @@ -0,0 +1,526 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import json # type: ignore +import re +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union + +from google.api_core import gapic_v1, path_template +from google.cloud.location import locations_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf import json_format + +from google.cloud.cloudsecuritycompliance_v1.types import monitoring + +from .base import DEFAULT_CLIENT_INFO, MonitoringTransport + + +class _BaseMonitoringRestTransport(MonitoringTransport): + """Base REST backend transport for Monitoring. + + Note: This class is not meant to be used directly. Use its sync and + async sub-classes instead. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends JSON representations of protocol buffers over HTTP/1.1 + """ + + def __init__( + self, + *, + host: str = "cloudsecuritycompliance.googleapis.com", + credentials: Optional[Any] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + url_scheme: str = "https", + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + Args: + host (Optional[str]): + The hostname to connect to (default: 'cloudsecuritycompliance.googleapis.com'). + credentials (Optional[Any]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you are developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + url_scheme: the protocol scheme for the API endpoint. Normally + "https", but for testing or local servers, + "http" can be specified. + """ + # Run the base constructor + maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host) + if maybe_url_match is None: + raise ValueError( + f"Unexpected hostname structure: {host}" + ) # pragma: NO COVER + + url_match_items = maybe_url_match.groupdict() + + host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host + + super().__init__( + host=host, + credentials=credentials, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + + class _BaseAggregateFrameworkComplianceReport: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/frameworkComplianceReports/*}:aggregate", + }, + { + "method": "get", + "uri": "/v1/{name=folders/*/locations/*/frameworkComplianceReports/*}:aggregate", + }, + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/frameworkComplianceReports/*}:aggregate", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = monitoring.AggregateFrameworkComplianceReportRequest.pb( + request + ) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMonitoringRestTransport._BaseAggregateFrameworkComplianceReport._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseFetchFrameworkComplianceReport: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/frameworkComplianceReports/*}:fetch", + }, + { + "method": "get", + "uri": "/v1/{name=folders/*/locations/*/frameworkComplianceReports/*}:fetch", + }, + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/frameworkComplianceReports/*}:fetch", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = monitoring.FetchFrameworkComplianceReportRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMonitoringRestTransport._BaseFetchFrameworkComplianceReport._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseListControlComplianceSummaries: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=organizations/*/locations/*/frameworkComplianceReports/*}/controlComplianceSummaries", + }, + { + "method": "get", + "uri": "/v1/{parent=folders/*/locations/*/frameworkComplianceReports/*}/controlComplianceSummaries", + }, + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*/frameworkComplianceReports/*}/controlComplianceSummaries", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = monitoring.ListControlComplianceSummariesRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMonitoringRestTransport._BaseListControlComplianceSummaries._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseListFindingSummaries: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=organizations/*/locations/*}/findingSummaries", + }, + { + "method": "get", + "uri": "/v1/{parent=folders/*/locations/*}/findingSummaries", + }, + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/findingSummaries", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = monitoring.ListFindingSummariesRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMonitoringRestTransport._BaseListFindingSummaries._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseListFrameworkComplianceSummaries: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=organizations/*/locations/*}/frameworkComplianceSummaries", + }, + { + "method": "get", + "uri": "/v1/{parent=folders/*/locations/*}/frameworkComplianceSummaries", + }, + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/frameworkComplianceSummaries", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = monitoring.ListFrameworkComplianceSummariesRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseMonitoringRestTransport._BaseListFrameworkComplianceSummaries._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseGetLocation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseListLocations: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*}/locations", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseCancelOperation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + body = json.dumps(transcoded_request["body"]) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseDeleteOperation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseGetOperation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseListOperations: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + +__all__ = ("_BaseMonitoringRestTransport",) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/__init__.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/__init__.py index d7bedb6888fa..52b649a192dc 100644 --- a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/__init__.py +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/__init__.py @@ -101,6 +101,30 @@ TargetResourceConfig, TargetResourceCreationConfig, ) +from .monitoring import ( + AggregatedComplianceReport, + AggregateFrameworkComplianceReportRequest, + AggregateFrameworkComplianceReportResponse, + CloudControlAssessmentDetails, + CloudControlReport, + ControlAssessmentDetails, + ControlComplianceSummary, + EvaluationState, + FetchFrameworkComplianceReportRequest, + FindingClass, + FindingSummary, + FrameworkComplianceReport, + FrameworkComplianceSummary, + ListControlComplianceSummariesRequest, + ListControlComplianceSummariesResponse, + ListFindingSummariesRequest, + ListFindingSummariesResponse, + ListFrameworkComplianceSummariesRequest, + ListFrameworkComplianceSummariesResponse, + ManualCloudControlAssessmentDetails, + SimilarControls, + TargetResourceDetails, +) __all__ = ( "BucketDestination", @@ -181,4 +205,26 @@ "TargetResourceConfig", "TargetResourceCreationConfig", "DeploymentState", + "AggregatedComplianceReport", + "AggregateFrameworkComplianceReportRequest", + "AggregateFrameworkComplianceReportResponse", + "CloudControlAssessmentDetails", + "CloudControlReport", + "ControlAssessmentDetails", + "ControlComplianceSummary", + "FetchFrameworkComplianceReportRequest", + "FindingSummary", + "FrameworkComplianceReport", + "FrameworkComplianceSummary", + "ListControlComplianceSummariesRequest", + "ListControlComplianceSummariesResponse", + "ListFindingSummariesRequest", + "ListFindingSummariesResponse", + "ListFrameworkComplianceSummariesRequest", + "ListFrameworkComplianceSummariesResponse", + "ManualCloudControlAssessmentDetails", + "SimilarControls", + "TargetResourceDetails", + "EvaluationState", + "FindingClass", ) diff --git a/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/monitoring.py b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/monitoring.py new file mode 100644 index 000000000000..d5d4d4750a9c --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/google/cloud/cloudsecuritycompliance_v1/types/monitoring.py @@ -0,0 +1,1034 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import annotations + +from typing import MutableMapping, MutableSequence + +from google.protobuf import timestamp_pb2 # type: ignore +from google.type import interval_pb2 # type: ignore +import proto # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.types import common + +__protobuf__ = proto.module( + package="google.cloud.cloudsecuritycompliance.v1", + manifest={ + "EvaluationState", + "FindingClass", + "ListFrameworkComplianceSummariesRequest", + "ListFrameworkComplianceSummariesResponse", + "FrameworkComplianceReport", + "FetchFrameworkComplianceReportRequest", + "ListFindingSummariesRequest", + "ListFindingSummariesResponse", + "ListControlComplianceSummariesRequest", + "ListControlComplianceSummariesResponse", + "AggregateFrameworkComplianceReportRequest", + "AggregateFrameworkComplianceReportResponse", + "ControlAssessmentDetails", + "FrameworkComplianceSummary", + "FindingSummary", + "ControlComplianceSummary", + "CloudControlReport", + "ManualCloudControlAssessmentDetails", + "CloudControlAssessmentDetails", + "SimilarControls", + "AggregatedComplianceReport", + "TargetResourceDetails", + }, +) + + +class EvaluationState(proto.Enum): + r"""The evaluation state of the control. + + Values: + EVALUATION_STATE_UNSPECIFIED (0): + Default value. This value is unused. + EVALUATION_STATE_PASSED (1): + The control is passing. + EVALUATION_STATE_FAILED (2): + The control is failing. + EVALUATION_STATE_NOT_ASSESSED (3): + The control is not assessed. + """ + EVALUATION_STATE_UNSPECIFIED = 0 + EVALUATION_STATE_PASSED = 1 + EVALUATION_STATE_FAILED = 2 + EVALUATION_STATE_NOT_ASSESSED = 3 + + +class FindingClass(proto.Enum): + r"""A finding is a record of assessment data like security, risk, + health, or privacy. + + Values: + FINDING_CLASS_UNSPECIFIED (0): + Default value. This value is unused. + THREAT (1): + The activity is unwanted or malicious. + VULNERABILITY (2): + A potential weakness in software that + increases risk to confidentiality, integrity, + and availability. + MISCONFIGURATION (3): + A potential weakness in a cloud resource or + asset configuration that increases risk. + OBSERVATION (4): + A security observation that is for + informational purposes. + SCC_ERROR (5): + An error that prevents Security Command + Center from functioning properly. + POSTURE_VIOLATION (6): + A potential security risk that's due to a + change in the security posture. + TOXIC_COMBINATION (7): + A combination of security issues that + represent a more severe security problem when + taken together. + SENSITIVE_DATA_RISK (8): + A potential security risk to data assets that + contain sensitive data. + CHOKEPOINT (9): + A resource or resource group where high risk + attack paths converge, based on attack path + simulations (APS). + """ + FINDING_CLASS_UNSPECIFIED = 0 + THREAT = 1 + VULNERABILITY = 2 + MISCONFIGURATION = 3 + OBSERVATION = 4 + SCC_ERROR = 5 + POSTURE_VIOLATION = 6 + TOXIC_COMBINATION = 7 + SENSITIVE_DATA_RISK = 8 + CHOKEPOINT = 9 + + +class ListFrameworkComplianceSummariesRequest(proto.Message): + r"""The request message for + [ListFrameworkComplianceSummariesRequest][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesRequest]. + + Attributes: + parent (str): + Required. The parent scope for the framework + compliance summary. + page_size (int): + Optional. The requested page size. The server + might return fewer items than requested. If + unspecified, the server picks an appropriate + default. + page_token (str): + Optional. A token that identifies the page of + results that the server should return. + filter (str): + Optional. The filtering results. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + page_size: int = proto.Field( + proto.INT32, + number=2, + ) + page_token: str = proto.Field( + proto.STRING, + number=3, + ) + filter: str = proto.Field( + proto.STRING, + number=4, + ) + + +class ListFrameworkComplianceSummariesResponse(proto.Message): + r"""The response message for + [ListFrameworkComplianceSummariesResponse][google.cloud.cloudsecuritycompliance.v1.ListFrameworkComplianceSummariesResponse]. + + Attributes: + framework_compliance_summaries (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.FrameworkComplianceSummary]): + The list of framework compliance summaries. + next_page_token (str): + Output only. The token to retrieve the next + page of results. + """ + + @property + def raw_page(self): + return self + + framework_compliance_summaries: MutableSequence[ + "FrameworkComplianceSummary" + ] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="FrameworkComplianceSummary", + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class FrameworkComplianceReport(proto.Message): + r"""The response message for [GetFrameworkComplianceReport][]. + + Attributes: + framework (str): + The name of the framework. + framework_description (str): + The description of the framework. + update_time (google.protobuf.timestamp_pb2.Timestamp): + Output only. The last updated time of the + report. + control_assessment_details (google.cloud.cloudsecuritycompliance_v1.types.ControlAssessmentDetails): + The control assessment details of the + framework. + framework_type (google.cloud.cloudsecuritycompliance_v1.types.Framework.FrameworkType): + The type of framework. + supported_cloud_providers (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.CloudProvider]): + The list of cloud providers supported by the + framework. + framework_categories (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.FrameworkCategory]): + The list of framework categories supported. + framework_display_name (str): + Optional. The display name for the framework. + name (str): + Identifier. The name of the framework + compliance report. + major_revision_id (int): + The latest major revision ID of the + framework. + minor_revision_id (int): + The latest minor revision ID of the latest + major revision of the framework. + target_resource_details (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.TargetResourceDetails]): + The target resource details of the framework. + """ + + framework: str = proto.Field( + proto.STRING, + number=1, + ) + framework_description: str = proto.Field( + proto.STRING, + number=2, + ) + update_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=3, + message=timestamp_pb2.Timestamp, + ) + control_assessment_details: "ControlAssessmentDetails" = proto.Field( + proto.MESSAGE, + number=4, + message="ControlAssessmentDetails", + ) + framework_type: common.Framework.FrameworkType = proto.Field( + proto.ENUM, + number=5, + enum=common.Framework.FrameworkType, + ) + supported_cloud_providers: MutableSequence[ + common.CloudProvider + ] = proto.RepeatedField( + proto.ENUM, + number=6, + enum=common.CloudProvider, + ) + framework_categories: MutableSequence[ + common.FrameworkCategory + ] = proto.RepeatedField( + proto.ENUM, + number=7, + enum=common.FrameworkCategory, + ) + framework_display_name: str = proto.Field( + proto.STRING, + number=8, + ) + name: str = proto.Field( + proto.STRING, + number=9, + ) + major_revision_id: int = proto.Field( + proto.INT64, + number=10, + ) + minor_revision_id: int = proto.Field( + proto.INT64, + number=11, + ) + target_resource_details: MutableSequence[ + "TargetResourceDetails" + ] = proto.RepeatedField( + proto.MESSAGE, + number=12, + message="TargetResourceDetails", + ) + + +class FetchFrameworkComplianceReportRequest(proto.Message): + r"""The request message for [FetchFrameworkComplianceReport][]. + + Attributes: + name (str): + Required. The name of the framework + compliance report to retrieve. + end_time (google.protobuf.timestamp_pb2.Timestamp): + Optional. The end time of the report. + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + end_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=2, + message=timestamp_pb2.Timestamp, + ) + + +class ListFindingSummariesRequest(proto.Message): + r"""The request message for [ListFindingSummaries][]. + + Attributes: + parent (str): + Required. The parent scope for the framework + overview page. + page_size (int): + Optional. The requested page size. The server + might return fewer items than requested. If + unspecified, the server picks an appropriate + default. + page_token (str): + Optional. A token that identifies the page of + results that the server should return. + filter (str): + Optional. The filtering results. + end_time (google.protobuf.timestamp_pb2.Timestamp): + Optional. The end time of the finding + summary. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + page_size: int = proto.Field( + proto.INT32, + number=2, + ) + page_token: str = proto.Field( + proto.STRING, + number=3, + ) + filter: str = proto.Field( + proto.STRING, + number=4, + ) + end_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=5, + message=timestamp_pb2.Timestamp, + ) + + +class ListFindingSummariesResponse(proto.Message): + r"""The response message for [ListFindingSummaries][]. + + Attributes: + finding_summaries (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.FindingSummary]): + List of finding summary by category. + next_page_token (str): + Output only. The token to retrieve the next + page of results. + """ + + @property + def raw_page(self): + return self + + finding_summaries: MutableSequence["FindingSummary"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="FindingSummary", + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class ListControlComplianceSummariesRequest(proto.Message): + r"""The request message for [ListControlComplianceSummaries][]. + + Attributes: + parent (str): + Required. The parent scope for the framework + overview page. + end_time (google.protobuf.timestamp_pb2.Timestamp): + Optional. The end time of the control + compliance summary. + page_size (int): + Optional. The requested page size. The server + might return fewer items than requested. If + unspecified, the server picks an appropriate + default. + page_token (str): + Optional. A token that identifies the page of + results that the server should return. + filter (str): + Optional. The filtering results. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + end_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=2, + message=timestamp_pb2.Timestamp, + ) + page_size: int = proto.Field( + proto.INT32, + number=3, + ) + page_token: str = proto.Field( + proto.STRING, + number=4, + ) + filter: str = proto.Field( + proto.STRING, + number=5, + ) + + +class ListControlComplianceSummariesResponse(proto.Message): + r"""The response message for [ListControlComplianceSummaries][]. + + Attributes: + control_compliance_summaries (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.ControlComplianceSummary]): + The list of control compliance details. + next_page_token (str): + Output only. The token to retrieve the next + page of results. + """ + + @property + def raw_page(self): + return self + + control_compliance_summaries: MutableSequence[ + "ControlComplianceSummary" + ] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="ControlComplianceSummary", + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class AggregateFrameworkComplianceReportRequest(proto.Message): + r"""The request message for [AggregateFrameworkComplianceReport][]. + + Attributes: + name (str): + Required. The name of the aggregated compliance report over + time to retrieve. + + The supported format is: + ``organizations/{organization_id}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}`` + interval (google.type.interval_pb2.Interval): + Optional. The start and end time range for + the aggregated compliance report. + filter (str): + Optional. The filtering results. + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + interval: interval_pb2.Interval = proto.Field( + proto.MESSAGE, + number=2, + message=interval_pb2.Interval, + ) + filter: str = proto.Field( + proto.STRING, + number=3, + ) + + +class AggregateFrameworkComplianceReportResponse(proto.Message): + r"""The response message for [AggregateFrameworkComplianceReport][]. + + Attributes: + aggregated_compliance_reports (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.AggregatedComplianceReport]): + The list of aggregated compliance reports. + """ + + aggregated_compliance_reports: MutableSequence[ + "AggregatedComplianceReport" + ] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="AggregatedComplianceReport", + ) + + +class ControlAssessmentDetails(proto.Message): + r"""The details for a control assessment. + + Attributes: + passing_controls (int): + The number of controls that are passing or + not assessed. + failing_controls (int): + The number of controls that are failing. + assessed_passing_controls (int): + The number of controls that were assessed and + are passing. + not_assessed_controls (int): + The number of controls that aren't assessed + because they require manual review. + """ + + passing_controls: int = proto.Field( + proto.INT32, + number=1, + ) + failing_controls: int = proto.Field( + proto.INT32, + number=2, + ) + assessed_passing_controls: int = proto.Field( + proto.INT32, + number=3, + ) + not_assessed_controls: int = proto.Field( + proto.INT32, + number=4, + ) + + +class FrameworkComplianceSummary(proto.Message): + r"""The details for a framework compliance summary. + + Attributes: + framework (str): + The name of the framework. + control_assessment_details (google.cloud.cloudsecuritycompliance_v1.types.ControlAssessmentDetails): + The control assessment details of the + framework. + framework_type (google.cloud.cloudsecuritycompliance_v1.types.Framework.FrameworkType): + The type of framework. + supported_cloud_providers (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.CloudProvider]): + The list of cloud providers supported by the + framework. + framework_categories (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.FrameworkCategory]): + The list of framework categories supported by + the framework. + framework_display_name (str): + Optional. The display name for the framework. + name (str): + Identifier. The name of the framework + compliance summary. + major_revision_id (int): + The major revision ID of the framework. + minor_revision_id (int): + The minor revision ID of the framework. + target_resource_details (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.TargetResourceDetails]): + The target resource details for the + framework. + """ + + framework: str = proto.Field( + proto.STRING, + number=1, + ) + control_assessment_details: "ControlAssessmentDetails" = proto.Field( + proto.MESSAGE, + number=2, + message="ControlAssessmentDetails", + ) + framework_type: common.Framework.FrameworkType = proto.Field( + proto.ENUM, + number=3, + enum=common.Framework.FrameworkType, + ) + supported_cloud_providers: MutableSequence[ + common.CloudProvider + ] = proto.RepeatedField( + proto.ENUM, + number=4, + enum=common.CloudProvider, + ) + framework_categories: MutableSequence[ + common.FrameworkCategory + ] = proto.RepeatedField( + proto.ENUM, + number=5, + enum=common.FrameworkCategory, + ) + framework_display_name: str = proto.Field( + proto.STRING, + number=6, + ) + name: str = proto.Field( + proto.STRING, + number=7, + ) + major_revision_id: int = proto.Field( + proto.INT64, + number=8, + ) + minor_revision_id: int = proto.Field( + proto.INT64, + number=9, + ) + target_resource_details: MutableSequence[ + "TargetResourceDetails" + ] = proto.RepeatedField( + proto.MESSAGE, + number=10, + message="TargetResourceDetails", + ) + + +class FindingSummary(proto.Message): + r"""The details for a finding. + + Attributes: + finding_category (str): + The category of the finding. + finding_class (google.cloud.cloudsecuritycompliance_v1.types.FindingClass): + The class of the finding. + severity (google.cloud.cloudsecuritycompliance_v1.types.Severity): + The severity of the finding. + finding_count (int): + The count of the finding. + update_time (google.protobuf.timestamp_pb2.Timestamp): + Output only. The last updated time of the + finding. + related_frameworks (MutableSequence[str]): + Optional. The list of compliance frameworks + that the finding belongs to. + name (str): + Identifier. The name of the finding summary. + """ + + finding_category: str = proto.Field( + proto.STRING, + number=1, + ) + finding_class: "FindingClass" = proto.Field( + proto.ENUM, + number=2, + enum="FindingClass", + ) + severity: common.Severity = proto.Field( + proto.ENUM, + number=3, + enum=common.Severity, + ) + finding_count: int = proto.Field( + proto.INT64, + number=4, + ) + update_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=5, + message=timestamp_pb2.Timestamp, + ) + related_frameworks: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=6, + ) + name: str = proto.Field( + proto.STRING, + number=7, + ) + + +class ControlComplianceSummary(proto.Message): + r"""The details for control compliance. + + Attributes: + control (str): + The name of the control. + display_name (str): + The display name of the control. + description (str): + The description of the control. + overall_evaluation_state (google.cloud.cloudsecuritycompliance_v1.types.EvaluationState): + Output only. The overall evaluation status of + the control. + total_findings_count (int): + The total number of findings for the control. + compliance_frameworks (MutableSequence[str]): + The list of compliance frameworks that the + control belongs to. + similar_controls (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.SimilarControls]): + The list of similar controls. + cloud_control_reports (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.CloudControlReport]): + The list of cloud control reports. + control_responsibility_type (google.cloud.cloudsecuritycompliance_v1.types.RegulatoryControlResponsibilityType): + The responsibility type for the control. + is_fake_control (bool): + Whether the control is a fake control. Fake + controls are created and mapped to cloud + controls that don't belong to a control group. + name (str): + Identifier. The name of the control + compliance summary. + """ + + control: str = proto.Field( + proto.STRING, + number=1, + ) + display_name: str = proto.Field( + proto.STRING, + number=2, + ) + description: str = proto.Field( + proto.STRING, + number=3, + ) + overall_evaluation_state: "EvaluationState" = proto.Field( + proto.ENUM, + number=4, + enum="EvaluationState", + ) + total_findings_count: int = proto.Field( + proto.INT32, + number=5, + ) + compliance_frameworks: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=6, + ) + similar_controls: MutableSequence["SimilarControls"] = proto.RepeatedField( + proto.MESSAGE, + number=7, + message="SimilarControls", + ) + cloud_control_reports: MutableSequence["CloudControlReport"] = proto.RepeatedField( + proto.MESSAGE, + number=8, + message="CloudControlReport", + ) + control_responsibility_type: common.RegulatoryControlResponsibilityType = ( + proto.Field( + proto.ENUM, + number=9, + enum=common.RegulatoryControlResponsibilityType, + ) + ) + is_fake_control: bool = proto.Field( + proto.BOOL, + number=10, + ) + name: str = proto.Field( + proto.STRING, + number=11, + ) + + +class CloudControlReport(proto.Message): + r"""The cloud control report. + + This message has `oneof`_ fields (mutually exclusive fields). + For each oneof, at most one member field can be set at the same time. + Setting any member of the oneof automatically clears all other + members. + + .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields + + Attributes: + manual_cloud_control_assessment_details (google.cloud.cloudsecuritycompliance_v1.types.ManualCloudControlAssessmentDetails): + The details of a manual cloud control + assessment. + + This field is a member of `oneof`_ ``assessment_details``. + cloud_control_assessment_details (google.cloud.cloudsecuritycompliance_v1.types.CloudControlAssessmentDetails): + The details of a cloud control assessment. + + This field is a member of `oneof`_ ``assessment_details``. + cloud_control (str): + The name of the cloud control. + display_name (str): + The display name of the cloud control. + description (str): + The description of the cloud control. + categories (MutableSequence[str]): + The list of categories for the cloud control. + similar_controls (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.SimilarControls]): + The list of similar controls. + cloud_control_type (google.cloud.cloudsecuritycompliance_v1.types.CloudControl.Type): + The type of the cloud control. + finding_category (str): + The category of the finding. + rules (MutableSequence[google.cloud.cloudsecuritycompliance_v1.types.Rule]): + The list of rules that correspond to the + cloud control. + finding_severity (google.cloud.cloudsecuritycompliance_v1.types.Severity): + The severity of the finding. + enforcement_mode (google.cloud.cloudsecuritycompliance_v1.types.EnforcementMode): + The enforcement mode of the cloud control. + cloud_control_deployment (str): + The name of the cloud control deployment. + major_revision_id (int): + The major revision ID of the cloud control. + minor_revision_id (int): + The minor revision ID of the cloud control. + framework_major_revision_ids (MutableSequence[int]): + The major revision IDs of the frameworks that + the cloud control belongs to. + """ + + manual_cloud_control_assessment_details: "ManualCloudControlAssessmentDetails" = ( + proto.Field( + proto.MESSAGE, + number=13, + oneof="assessment_details", + message="ManualCloudControlAssessmentDetails", + ) + ) + cloud_control_assessment_details: "CloudControlAssessmentDetails" = proto.Field( + proto.MESSAGE, + number=14, + oneof="assessment_details", + message="CloudControlAssessmentDetails", + ) + cloud_control: str = proto.Field( + proto.STRING, + number=1, + ) + display_name: str = proto.Field( + proto.STRING, + number=2, + ) + description: str = proto.Field( + proto.STRING, + number=3, + ) + categories: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=6, + ) + similar_controls: MutableSequence["SimilarControls"] = proto.RepeatedField( + proto.MESSAGE, + number=9, + message="SimilarControls", + ) + cloud_control_type: common.CloudControl.Type = proto.Field( + proto.ENUM, + number=10, + enum=common.CloudControl.Type, + ) + finding_category: str = proto.Field( + proto.STRING, + number=11, + ) + rules: MutableSequence[common.Rule] = proto.RepeatedField( + proto.MESSAGE, + number=12, + message=common.Rule, + ) + finding_severity: common.Severity = proto.Field( + proto.ENUM, + number=15, + enum=common.Severity, + ) + enforcement_mode: common.EnforcementMode = proto.Field( + proto.ENUM, + number=16, + enum=common.EnforcementMode, + ) + cloud_control_deployment: str = proto.Field( + proto.STRING, + number=17, + ) + major_revision_id: int = proto.Field( + proto.INT64, + number=18, + ) + minor_revision_id: int = proto.Field( + proto.INT64, + number=19, + ) + framework_major_revision_ids: MutableSequence[int] = proto.RepeatedField( + proto.INT64, + number=20, + ) + + +class ManualCloudControlAssessmentDetails(proto.Message): + r"""The details for a manual cloud control assessment. + + Attributes: + manual_cloud_control_guide (MutableSequence[str]): + The guide for assessing a cloud control + manually. + """ + + manual_cloud_control_guide: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=1, + ) + + +class CloudControlAssessmentDetails(proto.Message): + r"""The cloud control assessment details for non-manual cloud + controls. + + Attributes: + findings_count (int): + The number of findings for the cloud control. + evaluation_state (google.cloud.cloudsecuritycompliance_v1.types.EvaluationState): + Output only. The evaluation status of the + cloud control. + """ + + findings_count: int = proto.Field( + proto.INT32, + number=1, + ) + evaluation_state: "EvaluationState" = proto.Field( + proto.ENUM, + number=2, + enum="EvaluationState", + ) + + +class SimilarControls(proto.Message): + r"""The similar controls. + + Attributes: + framework (str): + The name of the framework. + control_id (str): + The ID of the control. + """ + + framework: str = proto.Field( + proto.STRING, + number=1, + ) + control_id: str = proto.Field( + proto.STRING, + number=2, + ) + + +class AggregatedComplianceReport(proto.Message): + r"""The aggregated compliance report. + + Attributes: + control_assessment_details (google.cloud.cloudsecuritycompliance_v1.types.ControlAssessmentDetails): + The control assessment details of the + framework. + report_time (google.protobuf.timestamp_pb2.Timestamp): + The report time of the aggregated compliance + report. + """ + + control_assessment_details: "ControlAssessmentDetails" = proto.Field( + proto.MESSAGE, + number=1, + message="ControlAssessmentDetails", + ) + report_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=2, + message=timestamp_pb2.Timestamp, + ) + + +class TargetResourceDetails(proto.Message): + r"""The details for a target resource. + + Attributes: + framework_deployment (str): + The framework deployment name for the target resource. + + For example, + ``organizations/{organization_id}/locations/{location}/frameworkDeployments/{framework_deployment_id}`` + target_resource_display_name (str): + The display name of the target resource. For example, + ``google.com``, ``staging-project``, or + ``development-folder``. + target_resource (str): + The target resource. For example, + ``organizations/1234567890``, ``projects/1234567890``, or + ``folders/1234567890``. + create_time (google.protobuf.timestamp_pb2.Timestamp): + The create time of the target resource. + update_time (google.protobuf.timestamp_pb2.Timestamp): + The update time of the target resource. + major_revision_id (int): + The major revision ID of the framework for + the target resource. + minor_revision_id (int): + The minor revision ID of the framework for + the target resource. + """ + + framework_deployment: str = proto.Field( + proto.STRING, + number=1, + ) + target_resource_display_name: str = proto.Field( + proto.STRING, + number=2, + ) + target_resource: str = proto.Field( + proto.STRING, + number=3, + ) + create_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=4, + message=timestamp_pb2.Timestamp, + ) + update_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=5, + message=timestamp_pb2.Timestamp, + ) + major_revision_id: int = proto.Field( + proto.INT64, + number=6, + ) + minor_revision_id: int = proto.Field( + proto.INT64, + number=7, + ) + + +__all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_async.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_async.py new file mode 100644 index 000000000000..75d3cdcec48c --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 AggregateFrameworkComplianceReport +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_AggregateFrameworkComplianceReport_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 cloudsecuritycompliance_v1 + + +async def sample_aggregate_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.AggregateFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = await client.aggregate_framework_compliance_report(request=request) + + # Handle the response + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_AggregateFrameworkComplianceReport_async] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_sync.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_sync.py new file mode 100644 index 000000000000..85809da6115e --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 AggregateFrameworkComplianceReport +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_AggregateFrameworkComplianceReport_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 cloudsecuritycompliance_v1 + + +def sample_aggregate_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.AggregateFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = client.aggregate_framework_compliance_report(request=request) + + # Handle the response + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_AggregateFrameworkComplianceReport_sync] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_async.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_async.py new file mode 100644 index 000000000000..99c42b9a04ed --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 FetchFrameworkComplianceReport +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_FetchFrameworkComplianceReport_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 cloudsecuritycompliance_v1 + + +async def sample_fetch_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.FetchFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = await client.fetch_framework_compliance_report(request=request) + + # Handle the response + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_FetchFrameworkComplianceReport_async] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_sync.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_sync.py new file mode 100644 index 000000000000..87ed6dba9cc5 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 FetchFrameworkComplianceReport +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_FetchFrameworkComplianceReport_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 cloudsecuritycompliance_v1 + + +def sample_fetch_framework_compliance_report(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.FetchFrameworkComplianceReportRequest( + name="name_value", + ) + + # Make the request + response = client.fetch_framework_compliance_report(request=request) + + # Handle the response + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_FetchFrameworkComplianceReport_sync] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_async.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_async.py new file mode 100644 index 000000000000..b71d72b18118 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListControlComplianceSummaries +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_ListControlComplianceSummaries_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 cloudsecuritycompliance_v1 + + +async def sample_list_control_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListControlComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_control_compliance_summaries(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_ListControlComplianceSummaries_async] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_sync.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_sync.py new file mode 100644 index 000000000000..04a10778251c --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListControlComplianceSummaries +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_ListControlComplianceSummaries_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 cloudsecuritycompliance_v1 + + +def sample_list_control_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListControlComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_control_compliance_summaries(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_ListControlComplianceSummaries_sync] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_async.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_async.py new file mode 100644 index 000000000000..4e10aad8c85b --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListFindingSummaries +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_ListFindingSummaries_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 cloudsecuritycompliance_v1 + + +async def sample_list_finding_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFindingSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_finding_summaries(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_ListFindingSummaries_async] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_sync.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_sync.py new file mode 100644 index 000000000000..7171c7f35929 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListFindingSummaries +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_ListFindingSummaries_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 cloudsecuritycompliance_v1 + + +def sample_list_finding_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFindingSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_finding_summaries(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_ListFindingSummaries_sync] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_async.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_async.py new file mode 100644 index 000000000000..961d7d163740 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListFrameworkComplianceSummaries +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_ListFrameworkComplianceSummaries_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 cloudsecuritycompliance_v1 + + +async def sample_list_framework_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringAsyncClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFrameworkComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_framework_compliance_summaries(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_ListFrameworkComplianceSummaries_async] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_sync.py b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_sync.py new file mode 100644 index 000000000000..089f739058ac --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListFrameworkComplianceSummaries +# 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-cloudsecuritycompliance + + +# [START cloudsecuritycompliance_v1_generated_Monitoring_ListFrameworkComplianceSummaries_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 cloudsecuritycompliance_v1 + + +def sample_list_framework_compliance_summaries(): + # Create a client + client = cloudsecuritycompliance_v1.MonitoringClient() + + # Initialize request argument(s) + request = cloudsecuritycompliance_v1.ListFrameworkComplianceSummariesRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_framework_compliance_summaries(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END cloudsecuritycompliance_v1_generated_Monitoring_ListFrameworkComplianceSummaries_sync] diff --git a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/snippet_metadata_google.cloud.cloudsecuritycompliance.v1.json b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/snippet_metadata_google.cloud.cloudsecuritycompliance.v1.json index 4a4fcab781bf..523bfe341d28 100644 --- a/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/snippet_metadata_google.cloud.cloudsecuritycompliance.v1.json +++ b/packages/google-cloud-cloudsecuritycompliance/samples/generated_samples/snippet_metadata_google.cloud.cloudsecuritycompliance.v1.json @@ -3644,6 +3644,811 @@ } ], "title": "cloudsecuritycompliance_v1_generated_deployment_list_framework_deployments_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient", + "shortName": "MonitoringAsyncClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.aggregate_framework_compliance_report", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.AggregateFrameworkComplianceReport", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "AggregateFrameworkComplianceReport" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportResponse", + "shortName": "aggregate_framework_compliance_report" + }, + "description": "Sample for AggregateFrameworkComplianceReport", + "file": "cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_AggregateFrameworkComplianceReport_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient", + "shortName": "MonitoringClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient.aggregate_framework_compliance_report", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.AggregateFrameworkComplianceReport", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "AggregateFrameworkComplianceReport" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.types.AggregateFrameworkComplianceReportResponse", + "shortName": "aggregate_framework_compliance_report" + }, + "description": "Sample for AggregateFrameworkComplianceReport", + "file": "cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_AggregateFrameworkComplianceReport_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_aggregate_framework_compliance_report_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient", + "shortName": "MonitoringAsyncClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.fetch_framework_compliance_report", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.FetchFrameworkComplianceReport", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "FetchFrameworkComplianceReport" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.FetchFrameworkComplianceReportRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.types.FrameworkComplianceReport", + "shortName": "fetch_framework_compliance_report" + }, + "description": "Sample for FetchFrameworkComplianceReport", + "file": "cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_FetchFrameworkComplianceReport_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient", + "shortName": "MonitoringClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient.fetch_framework_compliance_report", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.FetchFrameworkComplianceReport", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "FetchFrameworkComplianceReport" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.FetchFrameworkComplianceReportRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.types.FrameworkComplianceReport", + "shortName": "fetch_framework_compliance_report" + }, + "description": "Sample for FetchFrameworkComplianceReport", + "file": "cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_FetchFrameworkComplianceReport_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_fetch_framework_compliance_report_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient", + "shortName": "MonitoringAsyncClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.list_control_compliance_summaries", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.ListControlComplianceSummaries", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "ListControlComplianceSummaries" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListControlComplianceSummariesAsyncPager", + "shortName": "list_control_compliance_summaries" + }, + "description": "Sample for ListControlComplianceSummaries", + "file": "cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_ListControlComplianceSummaries_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient", + "shortName": "MonitoringClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient.list_control_compliance_summaries", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.ListControlComplianceSummaries", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "ListControlComplianceSummaries" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.ListControlComplianceSummariesRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListControlComplianceSummariesPager", + "shortName": "list_control_compliance_summaries" + }, + "description": "Sample for ListControlComplianceSummaries", + "file": "cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_ListControlComplianceSummaries_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_list_control_compliance_summaries_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient", + "shortName": "MonitoringAsyncClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.list_finding_summaries", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.ListFindingSummaries", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "ListFindingSummaries" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFindingSummariesAsyncPager", + "shortName": "list_finding_summaries" + }, + "description": "Sample for ListFindingSummaries", + "file": "cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_ListFindingSummaries_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient", + "shortName": "MonitoringClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient.list_finding_summaries", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.ListFindingSummaries", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "ListFindingSummaries" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.ListFindingSummariesRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFindingSummariesPager", + "shortName": "list_finding_summaries" + }, + "description": "Sample for ListFindingSummaries", + "file": "cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_ListFindingSummaries_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_list_finding_summaries_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient", + "shortName": "MonitoringAsyncClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringAsyncClient.list_framework_compliance_summaries", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.ListFrameworkComplianceSummaries", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "ListFrameworkComplianceSummaries" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFrameworkComplianceSummariesAsyncPager", + "shortName": "list_framework_compliance_summaries" + }, + "description": "Sample for ListFrameworkComplianceSummaries", + "file": "cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_ListFrameworkComplianceSummaries_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient", + "shortName": "MonitoringClient" + }, + "fullName": "google.cloud.cloudsecuritycompliance_v1.MonitoringClient.list_framework_compliance_summaries", + "method": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring.ListFrameworkComplianceSummaries", + "service": { + "fullName": "google.cloud.cloudsecuritycompliance.v1.Monitoring", + "shortName": "Monitoring" + }, + "shortName": "ListFrameworkComplianceSummaries" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.cloudsecuritycompliance_v1.types.ListFrameworkComplianceSummariesRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.cloudsecuritycompliance_v1.services.monitoring.pagers.ListFrameworkComplianceSummariesPager", + "shortName": "list_framework_compliance_summaries" + }, + "description": "Sample for ListFrameworkComplianceSummaries", + "file": "cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudsecuritycompliance_v1_generated_Monitoring_ListFrameworkComplianceSummaries_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudsecuritycompliance_v1_generated_monitoring_list_framework_compliance_summaries_sync.py" } ] } diff --git a/packages/google-cloud-cloudsecuritycompliance/scripts/fixup_cloudsecuritycompliance_v1_keywords.py b/packages/google-cloud-cloudsecuritycompliance/scripts/fixup_cloudsecuritycompliance_v1_keywords.py index 92224c429cf7..e05ac1677e0f 100644 --- a/packages/google-cloud-cloudsecuritycompliance/scripts/fixup_cloudsecuritycompliance_v1_keywords.py +++ b/packages/google-cloud-cloudsecuritycompliance/scripts/fixup_cloudsecuritycompliance_v1_keywords.py @@ -39,6 +39,7 @@ def partition( class cloudsecuritycomplianceCallTransformer(cst.CSTTransformer): CTRL_PARAMS: Tuple[str] = ('retry', 'timeout', 'metadata') METHOD_TO_PARAMS: Dict[str, Tuple[str]] = { + 'aggregate_framework_compliance_report': ('name', 'interval', 'filter', ), 'calculate_effective_cm_enrollment': ('name', ), 'create_cloud_control': ('parent', 'cloud_control_id', 'cloud_control', ), 'create_framework': ('parent', 'framework_id', 'framework', ), @@ -47,6 +48,7 @@ class cloudsecuritycomplianceCallTransformer(cst.CSTTransformer): 'delete_cloud_control': ('name', ), 'delete_framework': ('name', ), 'delete_framework_deployment': ('name', 'etag', ), + 'fetch_framework_compliance_report': ('name', 'end_time', ), 'generate_framework_audit_scope_report': ('scope', 'report_format', 'compliance_framework', ), 'get_cloud_control': ('name', 'major_revision_id', ), 'get_cloud_control_deployment': ('name', ), @@ -55,7 +57,10 @@ class cloudsecuritycomplianceCallTransformer(cst.CSTTransformer): 'get_framework_deployment': ('name', ), 'list_cloud_control_deployments': ('parent', 'page_size', 'page_token', 'filter', 'order_by', ), 'list_cloud_controls': ('parent', 'page_size', 'page_token', ), + 'list_control_compliance_summaries': ('parent', 'end_time', 'page_size', 'page_token', 'filter', ), + 'list_finding_summaries': ('parent', 'page_size', 'page_token', 'filter', 'end_time', ), 'list_framework_audits': ('parent', 'page_size', 'page_token', 'filter', ), + 'list_framework_compliance_summaries': ('parent', 'page_size', 'page_token', 'filter', ), 'list_framework_deployments': ('parent', 'page_size', 'page_token', 'filter', 'order_by', ), 'list_frameworks': ('parent', 'page_size', 'page_token', ), 'update_cloud_control': ('cloud_control', 'update_mask', ), diff --git a/packages/google-cloud-cloudsecuritycompliance/tests/unit/gapic/cloudsecuritycompliance_v1/test_monitoring.py b/packages/google-cloud-cloudsecuritycompliance/tests/unit/gapic/cloudsecuritycompliance_v1/test_monitoring.py new file mode 100644 index 000000000000..c11d42c0d618 --- /dev/null +++ b/packages/google-cloud-cloudsecuritycompliance/tests/unit/gapic/cloudsecuritycompliance_v1/test_monitoring.py @@ -0,0 +1,7873 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import os + +# try/except added for compatibility with python < 3.8 +try: + from unittest import mock + from unittest.mock import AsyncMock # pragma: NO COVER +except ImportError: # pragma: NO COVER + import mock + +from collections.abc import AsyncIterable, Iterable +import json +import math + +from google.api_core import api_core_version +from google.protobuf import json_format +import grpc +from grpc.experimental import aio +from proto.marshal.rules import wrappers +from proto.marshal.rules.dates import DurationRule, TimestampRule +import pytest +from requests import PreparedRequest, Request, Response +from requests.sessions import Session + +try: + from google.auth.aio import credentials as ga_credentials_async + + HAS_GOOGLE_AUTH_AIO = True +except ImportError: # pragma: NO COVER + HAS_GOOGLE_AUTH_AIO = False + +from google.api_core import gapic_v1, grpc_helpers, grpc_helpers_async, path_template +from google.api_core import client_options +from google.api_core import exceptions as core_exceptions +from google.api_core import retry as retries +import google.auth +from google.auth import credentials as ga_credentials +from google.auth.exceptions import MutualTLSChannelError +from google.cloud.location import locations_pb2 +from google.longrunning import operations_pb2 # type: ignore +from google.oauth2 import service_account +from google.protobuf import timestamp_pb2 # type: ignore +from google.type import interval_pb2 # type: ignore + +from google.cloud.cloudsecuritycompliance_v1.services.monitoring import ( + MonitoringAsyncClient, + MonitoringClient, + pagers, + transports, +) +from google.cloud.cloudsecuritycompliance_v1.types import common, monitoring + +CRED_INFO_JSON = { + "credential_source": "/path/to/file", + "credential_type": "service account credentials", + "principal": "service-account@example.com", +} +CRED_INFO_STRING = json.dumps(CRED_INFO_JSON) + + +async def mock_async_gen(data, chunk_size=1): + for i in range(0, len(data)): # pragma: NO COVER + chunk = data[i : i + chunk_size] + yield chunk.encode("utf-8") + + +def client_cert_source_callback(): + return b"cert bytes", b"key bytes" + + +# TODO: use async auth anon credentials by default once the minimum version of google-auth is upgraded. +# See related issue: https://github.com/googleapis/gapic-generator-python/issues/2107. +def async_anonymous_credentials(): + if HAS_GOOGLE_AUTH_AIO: + return ga_credentials_async.AnonymousCredentials() + return ga_credentials.AnonymousCredentials() + + +# If default endpoint is localhost, then default mtls endpoint will be the same. +# This method modifies the default endpoint so the client can produce a different +# mtls endpoint for endpoint testing purposes. +def modify_default_endpoint(client): + return ( + "foo.googleapis.com" + if ("localhost" in client.DEFAULT_ENDPOINT) + else client.DEFAULT_ENDPOINT + ) + + +# If default endpoint template is localhost, then default mtls endpoint will be the same. +# This method modifies the default endpoint template so the client can produce a different +# mtls endpoint for endpoint testing purposes. +def modify_default_endpoint_template(client): + return ( + "test.{UNIVERSE_DOMAIN}" + if ("localhost" in client._DEFAULT_ENDPOINT_TEMPLATE) + else client._DEFAULT_ENDPOINT_TEMPLATE + ) + + +def test__get_default_mtls_endpoint(): + api_endpoint = "example.googleapis.com" + api_mtls_endpoint = "example.mtls.googleapis.com" + sandbox_endpoint = "example.sandbox.googleapis.com" + sandbox_mtls_endpoint = "example.mtls.sandbox.googleapis.com" + non_googleapi = "api.example.com" + + assert MonitoringClient._get_default_mtls_endpoint(None) is None + assert ( + MonitoringClient._get_default_mtls_endpoint(api_endpoint) == api_mtls_endpoint + ) + assert ( + MonitoringClient._get_default_mtls_endpoint(api_mtls_endpoint) + == api_mtls_endpoint + ) + assert ( + MonitoringClient._get_default_mtls_endpoint(sandbox_endpoint) + == sandbox_mtls_endpoint + ) + assert ( + MonitoringClient._get_default_mtls_endpoint(sandbox_mtls_endpoint) + == sandbox_mtls_endpoint + ) + assert MonitoringClient._get_default_mtls_endpoint(non_googleapi) == non_googleapi + + +def test__read_environment_variables(): + assert MonitoringClient._read_environment_variables() == (False, "auto", None) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + assert MonitoringClient._read_environment_variables() == (True, "auto", None) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}): + assert MonitoringClient._read_environment_variables() == (False, "auto", None) + + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError) as excinfo: + MonitoringClient._read_environment_variables() + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + assert MonitoringClient._read_environment_variables() == (False, "never", None) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + assert MonitoringClient._read_environment_variables() == (False, "always", None) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"}): + assert MonitoringClient._read_environment_variables() == (False, "auto", None) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError) as excinfo: + MonitoringClient._read_environment_variables() + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + with mock.patch.dict(os.environ, {"GOOGLE_CLOUD_UNIVERSE_DOMAIN": "foo.com"}): + assert MonitoringClient._read_environment_variables() == ( + False, + "auto", + "foo.com", + ) + + +def test__get_client_cert_source(): + mock_provided_cert_source = mock.Mock() + mock_default_cert_source = mock.Mock() + + assert MonitoringClient._get_client_cert_source(None, False) is None + assert ( + MonitoringClient._get_client_cert_source(mock_provided_cert_source, False) + is None + ) + assert ( + MonitoringClient._get_client_cert_source(mock_provided_cert_source, True) + == mock_provided_cert_source + ) + + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", return_value=True + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=mock_default_cert_source, + ): + assert ( + MonitoringClient._get_client_cert_source(None, True) + is mock_default_cert_source + ) + assert ( + MonitoringClient._get_client_cert_source( + mock_provided_cert_source, "true" + ) + is mock_provided_cert_source + ) + + +@mock.patch.object( + MonitoringClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringClient), +) +@mock.patch.object( + MonitoringAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringAsyncClient), +) +def test__get_api_endpoint(): + api_override = "foo.com" + mock_client_cert_source = mock.Mock() + default_universe = MonitoringClient._DEFAULT_UNIVERSE + default_endpoint = MonitoringClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=default_universe + ) + mock_universe = "bar.com" + mock_endpoint = MonitoringClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=mock_universe + ) + + assert ( + MonitoringClient._get_api_endpoint( + api_override, mock_client_cert_source, default_universe, "always" + ) + == api_override + ) + assert ( + MonitoringClient._get_api_endpoint( + None, mock_client_cert_source, default_universe, "auto" + ) + == MonitoringClient.DEFAULT_MTLS_ENDPOINT + ) + assert ( + MonitoringClient._get_api_endpoint(None, None, default_universe, "auto") + == default_endpoint + ) + assert ( + MonitoringClient._get_api_endpoint(None, None, default_universe, "always") + == MonitoringClient.DEFAULT_MTLS_ENDPOINT + ) + assert ( + MonitoringClient._get_api_endpoint( + None, mock_client_cert_source, default_universe, "always" + ) + == MonitoringClient.DEFAULT_MTLS_ENDPOINT + ) + assert ( + MonitoringClient._get_api_endpoint(None, None, mock_universe, "never") + == mock_endpoint + ) + assert ( + MonitoringClient._get_api_endpoint(None, None, default_universe, "never") + == default_endpoint + ) + + with pytest.raises(MutualTLSChannelError) as excinfo: + MonitoringClient._get_api_endpoint( + None, mock_client_cert_source, mock_universe, "auto" + ) + assert ( + str(excinfo.value) + == "mTLS is not supported in any universe other than googleapis.com." + ) + + +def test__get_universe_domain(): + client_universe_domain = "foo.com" + universe_domain_env = "bar.com" + + assert ( + MonitoringClient._get_universe_domain( + client_universe_domain, universe_domain_env + ) + == client_universe_domain + ) + assert ( + MonitoringClient._get_universe_domain(None, universe_domain_env) + == universe_domain_env + ) + assert ( + MonitoringClient._get_universe_domain(None, None) + == MonitoringClient._DEFAULT_UNIVERSE + ) + + with pytest.raises(ValueError) as excinfo: + MonitoringClient._get_universe_domain("", None) + assert str(excinfo.value) == "Universe Domain cannot be an empty string." + + +@pytest.mark.parametrize( + "error_code,cred_info_json,show_cred_info", + [ + (401, CRED_INFO_JSON, True), + (403, CRED_INFO_JSON, True), + (404, CRED_INFO_JSON, True), + (500, CRED_INFO_JSON, False), + (401, None, False), + (403, None, False), + (404, None, False), + (500, None, False), + ], +) +def test__add_cred_info_for_auth_errors(error_code, cred_info_json, show_cred_info): + cred = mock.Mock(["get_cred_info"]) + cred.get_cred_info = mock.Mock(return_value=cred_info_json) + client = MonitoringClient(credentials=cred) + client._transport._credentials = cred + + error = core_exceptions.GoogleAPICallError("message", details=["foo"]) + error.code = error_code + + client._add_cred_info_for_auth_errors(error) + if show_cred_info: + assert error.details == ["foo", CRED_INFO_STRING] + else: + assert error.details == ["foo"] + + +@pytest.mark.parametrize("error_code", [401, 403, 404, 500]) +def test__add_cred_info_for_auth_errors_no_get_cred_info(error_code): + cred = mock.Mock([]) + assert not hasattr(cred, "get_cred_info") + client = MonitoringClient(credentials=cred) + client._transport._credentials = cred + + error = core_exceptions.GoogleAPICallError("message", details=[]) + error.code = error_code + + client._add_cred_info_for_auth_errors(error) + assert error.details == [] + + +@pytest.mark.parametrize( + "client_class,transport_name", + [ + (MonitoringClient, "grpc"), + (MonitoringAsyncClient, "grpc_asyncio"), + (MonitoringClient, "rest"), + ], +) +def test_monitoring_client_from_service_account_info(client_class, transport_name): + creds = ga_credentials.AnonymousCredentials() + with mock.patch.object( + service_account.Credentials, "from_service_account_info" + ) as factory: + factory.return_value = creds + info = {"valid": True} + client = client_class.from_service_account_info(info, transport=transport_name) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + assert client.transport._host == ( + "cloudsecuritycompliance.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://cloudsecuritycompliance.googleapis.com" + ) + + +@pytest.mark.parametrize( + "transport_class,transport_name", + [ + (transports.MonitoringGrpcTransport, "grpc"), + (transports.MonitoringGrpcAsyncIOTransport, "grpc_asyncio"), + (transports.MonitoringRestTransport, "rest"), + ], +) +def test_monitoring_client_service_account_always_use_jwt( + transport_class, transport_name +): + with mock.patch.object( + service_account.Credentials, "with_always_use_jwt_access", create=True + ) as use_jwt: + creds = service_account.Credentials(None, None, None) + transport = transport_class(credentials=creds, always_use_jwt_access=True) + use_jwt.assert_called_once_with(True) + + with mock.patch.object( + service_account.Credentials, "with_always_use_jwt_access", create=True + ) as use_jwt: + creds = service_account.Credentials(None, None, None) + transport = transport_class(credentials=creds, always_use_jwt_access=False) + use_jwt.assert_not_called() + + +@pytest.mark.parametrize( + "client_class,transport_name", + [ + (MonitoringClient, "grpc"), + (MonitoringAsyncClient, "grpc_asyncio"), + (MonitoringClient, "rest"), + ], +) +def test_monitoring_client_from_service_account_file(client_class, transport_name): + creds = ga_credentials.AnonymousCredentials() + with mock.patch.object( + service_account.Credentials, "from_service_account_file" + ) as factory: + factory.return_value = creds + client = client_class.from_service_account_file( + "dummy/file/path.json", transport=transport_name + ) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + client = client_class.from_service_account_json( + "dummy/file/path.json", transport=transport_name + ) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + assert client.transport._host == ( + "cloudsecuritycompliance.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://cloudsecuritycompliance.googleapis.com" + ) + + +def test_monitoring_client_get_transport_class(): + transport = MonitoringClient.get_transport_class() + available_transports = [ + transports.MonitoringGrpcTransport, + transports.MonitoringRestTransport, + ] + assert transport in available_transports + + transport = MonitoringClient.get_transport_class("grpc") + assert transport == transports.MonitoringGrpcTransport + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + (MonitoringClient, transports.MonitoringGrpcTransport, "grpc"), + ( + MonitoringAsyncClient, + transports.MonitoringGrpcAsyncIOTransport, + "grpc_asyncio", + ), + (MonitoringClient, transports.MonitoringRestTransport, "rest"), + ], +) +@mock.patch.object( + MonitoringClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringClient), +) +@mock.patch.object( + MonitoringAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringAsyncClient), +) +def test_monitoring_client_client_options( + client_class, transport_class, transport_name +): + # Check that if channel is provided we won't create a new one. + with mock.patch.object(MonitoringClient, "get_transport_class") as gtc: + transport = transport_class(credentials=ga_credentials.AnonymousCredentials()) + client = client_class(transport=transport) + gtc.assert_not_called() + + # Check that if channel is provided via str we will create a new one. + with mock.patch.object(MonitoringClient, "get_transport_class") as gtc: + client = client_class(transport=transport_name) + gtc.assert_called() + + # Check the case api_endpoint is provided. + options = client_options.ClientOptions(api_endpoint="squid.clam.whelk") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(transport=transport_name, client_options=options) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host="squid.clam.whelk", + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is + # "never". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is + # "always". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_MTLS_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has + # unsupported value. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError) as excinfo: + client = client_class(transport=transport_name) + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + # Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError) as excinfo: + client = client_class(transport=transport_name) + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + + # Check the case quota_project_id is provided + options = client_options.ClientOptions(quota_project_id="octopus") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id="octopus", + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + # Check the case api_endpoint is provided + options = client_options.ClientOptions( + api_audience="https://language.googleapis.com" + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience="https://language.googleapis.com", + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,use_client_cert_env", + [ + (MonitoringClient, transports.MonitoringGrpcTransport, "grpc", "true"), + ( + MonitoringAsyncClient, + transports.MonitoringGrpcAsyncIOTransport, + "grpc_asyncio", + "true", + ), + (MonitoringClient, transports.MonitoringGrpcTransport, "grpc", "false"), + ( + MonitoringAsyncClient, + transports.MonitoringGrpcAsyncIOTransport, + "grpc_asyncio", + "false", + ), + (MonitoringClient, transports.MonitoringRestTransport, "rest", "true"), + (MonitoringClient, transports.MonitoringRestTransport, "rest", "false"), + ], +) +@mock.patch.object( + MonitoringClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringClient), +) +@mock.patch.object( + MonitoringAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringAsyncClient), +) +@mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"}) +def test_monitoring_client_mtls_env_auto( + client_class, transport_class, transport_name, use_client_cert_env +): + # This tests the endpoint autoswitch behavior. Endpoint is autoswitched to the default + # mtls endpoint, if GOOGLE_API_USE_CLIENT_CERTIFICATE is "true" and client cert exists. + + # Check the case client_cert_source is provided. Whether client cert is used depends on + # GOOGLE_API_USE_CLIENT_CERTIFICATE value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + options = client_options.ClientOptions( + client_cert_source=client_cert_source_callback + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + + if use_client_cert_env == "false": + expected_client_cert_source = None + expected_host = client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ) + else: + expected_client_cert_source = client_cert_source_callback + expected_host = client.DEFAULT_MTLS_ENDPOINT + + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=expected_host, + scopes=None, + client_cert_source_for_mtls=expected_client_cert_source, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case ADC client cert is provided. Whether client cert is used depends on + # GOOGLE_API_USE_CLIENT_CERTIFICATE value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + with mock.patch.object(transport_class, "__init__") as patched: + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=True, + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=client_cert_source_callback, + ): + if use_client_cert_env == "false": + expected_host = client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ) + expected_client_cert_source = None + else: + expected_host = client.DEFAULT_MTLS_ENDPOINT + expected_client_cert_source = client_cert_source_callback + + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=expected_host, + scopes=None, + client_cert_source_for_mtls=expected_client_cert_source, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case client_cert_source and ADC client cert are not provided. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + with mock.patch.object(transport_class, "__init__") as patched: + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=False, + ): + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +@pytest.mark.parametrize("client_class", [MonitoringClient, MonitoringAsyncClient]) +@mock.patch.object( + MonitoringClient, "DEFAULT_ENDPOINT", modify_default_endpoint(MonitoringClient) +) +@mock.patch.object( + MonitoringAsyncClient, + "DEFAULT_ENDPOINT", + modify_default_endpoint(MonitoringAsyncClient), +) +def test_monitoring_client_get_mtls_endpoint_and_cert_source(client_class): + mock_client_cert_source = mock.Mock() + + # Test the case GOOGLE_API_USE_CLIENT_CERTIFICATE is "true". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + mock_api_endpoint = "foo" + options = client_options.ClientOptions( + client_cert_source=mock_client_cert_source, api_endpoint=mock_api_endpoint + ) + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source( + options + ) + assert api_endpoint == mock_api_endpoint + assert cert_source == mock_client_cert_source + + # Test the case GOOGLE_API_USE_CLIENT_CERTIFICATE is "false". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}): + mock_client_cert_source = mock.Mock() + mock_api_endpoint = "foo" + options = client_options.ClientOptions( + client_cert_source=mock_client_cert_source, api_endpoint=mock_api_endpoint + ) + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source( + options + ) + assert api_endpoint == mock_api_endpoint + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "never". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_ENDPOINT + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "always". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "auto" and default cert doesn't exist. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=False, + ): + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_ENDPOINT + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "auto" and default cert exists. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=True, + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=mock_client_cert_source, + ): + ( + api_endpoint, + cert_source, + ) = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT + assert cert_source == mock_client_cert_source + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has + # unsupported value. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError) as excinfo: + client_class.get_mtls_endpoint_and_cert_source() + + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + # Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError) as excinfo: + client_class.get_mtls_endpoint_and_cert_source() + + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + + +@pytest.mark.parametrize("client_class", [MonitoringClient, MonitoringAsyncClient]) +@mock.patch.object( + MonitoringClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringClient), +) +@mock.patch.object( + MonitoringAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(MonitoringAsyncClient), +) +def test_monitoring_client_client_api_endpoint(client_class): + mock_client_cert_source = client_cert_source_callback + api_override = "foo.com" + default_universe = MonitoringClient._DEFAULT_UNIVERSE + default_endpoint = MonitoringClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=default_universe + ) + mock_universe = "bar.com" + mock_endpoint = MonitoringClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=mock_universe + ) + + # If ClientOptions.api_endpoint is set and GOOGLE_API_USE_CLIENT_CERTIFICATE="true", + # use ClientOptions.api_endpoint as the api endpoint regardless. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + with mock.patch( + "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel" + ): + options = client_options.ClientOptions( + client_cert_source=mock_client_cert_source, api_endpoint=api_override + ) + client = client_class( + client_options=options, + credentials=ga_credentials.AnonymousCredentials(), + ) + assert client.api_endpoint == api_override + + # If ClientOptions.api_endpoint is not set and GOOGLE_API_USE_MTLS_ENDPOINT="never", + # use the _DEFAULT_ENDPOINT_TEMPLATE populated with GDU as the api endpoint. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + client = client_class(credentials=ga_credentials.AnonymousCredentials()) + assert client.api_endpoint == default_endpoint + + # If ClientOptions.api_endpoint is not set and GOOGLE_API_USE_MTLS_ENDPOINT="always", + # use the DEFAULT_MTLS_ENDPOINT as the api endpoint. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + client = client_class(credentials=ga_credentials.AnonymousCredentials()) + assert client.api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT + + # If ClientOptions.api_endpoint is not set, GOOGLE_API_USE_MTLS_ENDPOINT="auto" (default), + # GOOGLE_API_USE_CLIENT_CERTIFICATE="false" (default), default cert source doesn't exist, + # and ClientOptions.universe_domain="bar.com", + # use the _DEFAULT_ENDPOINT_TEMPLATE populated with universe domain as the api endpoint. + options = client_options.ClientOptions() + universe_exists = hasattr(options, "universe_domain") + if universe_exists: + options = client_options.ClientOptions(universe_domain=mock_universe) + client = client_class( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + else: + client = client_class( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + assert client.api_endpoint == ( + mock_endpoint if universe_exists else default_endpoint + ) + assert client.universe_domain == ( + mock_universe if universe_exists else default_universe + ) + + # If ClientOptions does not have a universe domain attribute and GOOGLE_API_USE_MTLS_ENDPOINT="never", + # use the _DEFAULT_ENDPOINT_TEMPLATE populated with GDU as the api endpoint. + options = client_options.ClientOptions() + if hasattr(options, "universe_domain"): + delattr(options, "universe_domain") + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + client = client_class( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + assert client.api_endpoint == default_endpoint + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + (MonitoringClient, transports.MonitoringGrpcTransport, "grpc"), + ( + MonitoringAsyncClient, + transports.MonitoringGrpcAsyncIOTransport, + "grpc_asyncio", + ), + (MonitoringClient, transports.MonitoringRestTransport, "rest"), + ], +) +def test_monitoring_client_client_options_scopes( + client_class, transport_class, transport_name +): + # Check the case scopes are provided. + options = client_options.ClientOptions( + scopes=["1", "2"], + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=["1", "2"], + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,grpc_helpers", + [ + (MonitoringClient, transports.MonitoringGrpcTransport, "grpc", grpc_helpers), + ( + MonitoringAsyncClient, + transports.MonitoringGrpcAsyncIOTransport, + "grpc_asyncio", + grpc_helpers_async, + ), + (MonitoringClient, transports.MonitoringRestTransport, "rest", None), + ], +) +def test_monitoring_client_client_options_credentials_file( + client_class, transport_class, transport_name, grpc_helpers +): + # Check the case credentials file is provided. + options = client_options.ClientOptions(credentials_file="credentials.json") + + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file="credentials.json", + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +def test_monitoring_client_client_options_from_dict(): + with mock.patch( + "google.cloud.cloudsecuritycompliance_v1.services.monitoring.transports.MonitoringGrpcTransport.__init__" + ) as grpc_transport: + grpc_transport.return_value = None + client = MonitoringClient(client_options={"api_endpoint": "squid.clam.whelk"}) + grpc_transport.assert_called_once_with( + credentials=None, + credentials_file=None, + host="squid.clam.whelk", + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,grpc_helpers", + [ + (MonitoringClient, transports.MonitoringGrpcTransport, "grpc", grpc_helpers), + ( + MonitoringAsyncClient, + transports.MonitoringGrpcAsyncIOTransport, + "grpc_asyncio", + grpc_helpers_async, + ), + ], +) +def test_monitoring_client_create_channel_credentials_file( + client_class, transport_class, transport_name, grpc_helpers +): + # Check the case credentials file is provided. + options = client_options.ClientOptions(credentials_file="credentials.json") + + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file="credentials.json", + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # test that the credentials from file are saved and used as the credentials. + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch.object( + google.auth, "default", autospec=True + ) as adc, mock.patch.object( + grpc_helpers, "create_channel" + ) as create_channel: + creds = ga_credentials.AnonymousCredentials() + file_creds = ga_credentials.AnonymousCredentials() + load_creds.return_value = (file_creds, None) + adc.return_value = (creds, None) + client = client_class(client_options=options, transport=transport_name) + create_channel.assert_called_with( + "cloudsecuritycompliance.googleapis.com:443", + credentials=file_creds, + credentials_file=None, + quota_project_id=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + scopes=None, + default_host="cloudsecuritycompliance.googleapis.com", + ssl_credentials=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.ListFrameworkComplianceSummariesRequest, + dict, + ], +) +def test_list_framework_compliance_summaries(request_type, transport: str = "grpc"): + client = MonitoringClient( + 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_framework_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListFrameworkComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + response = client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = monitoring.ListFrameworkComplianceSummariesRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListFrameworkComplianceSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_framework_compliance_summaries_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = monitoring.ListFrameworkComplianceSummariesRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_framework_compliance_summaries(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == monitoring.ListFrameworkComplianceSummariesRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + +def test_list_framework_compliance_summaries_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_framework_compliance_summaries + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_framework_compliance_summaries + ] = mock_rpc + request = {} + client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_framework_compliance_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.list_framework_compliance_summaries + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.list_framework_compliance_summaries + ] = mock_rpc + + request = {} + await client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.list_framework_compliance_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_async( + transport: str = "grpc_asyncio", + request_type=monitoring.ListFrameworkComplianceSummariesRequest, +): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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_framework_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFrameworkComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = monitoring.ListFrameworkComplianceSummariesRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListFrameworkComplianceSummariesAsyncPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_async_from_dict(): + await test_list_framework_compliance_summaries_async(request_type=dict) + + +def test_list_framework_compliance_summaries_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.ListFrameworkComplianceSummariesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + call.return_value = monitoring.ListFrameworkComplianceSummariesResponse() + client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.ListFrameworkComplianceSummariesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFrameworkComplianceSummariesResponse() + ) + await client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_list_framework_compliance_summaries_flattened(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListFrameworkComplianceSummariesResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_framework_compliance_summaries( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +def test_list_framework_compliance_summaries_flattened_error(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_framework_compliance_summaries( + monitoring.ListFrameworkComplianceSummariesRequest(), + parent="parent_value", + ) + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_flattened_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListFrameworkComplianceSummariesResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFrameworkComplianceSummariesResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_framework_compliance_summaries( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_flattened_error_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.list_framework_compliance_summaries( + monitoring.ListFrameworkComplianceSummariesRequest(), + parent="parent_value", + ) + + +def test_list_framework_compliance_summaries_pager(transport_name: str = "grpc"): + client = MonitoringClient( + 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_framework_compliance_summaries), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + ), + RuntimeError, + ) + + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_framework_compliance_summaries( + request={}, retry=retry, timeout=timeout + ) + + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, monitoring.FrameworkComplianceSummary) for i in results + ) + + +def test_list_framework_compliance_summaries_pages(transport_name: str = "grpc"): + client = MonitoringClient( + 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_framework_compliance_summaries), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + ), + RuntimeError, + ) + pages = list(client.list_framework_compliance_summaries(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_framework_compliance_summaries_async_pager(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + ), + RuntimeError, + ) + async_pager = await client.list_framework_compliance_summaries( + 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, monitoring.FrameworkComplianceSummary) for i in responses + ) + + +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_async_pages(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + ), + 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_framework_compliance_summaries(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", + [ + monitoring.ListFindingSummariesRequest, + dict, + ], +) +def test_list_finding_summaries(request_type, transport: str = "grpc"): + client = MonitoringClient( + 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_finding_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListFindingSummariesResponse( + next_page_token="next_page_token_value", + ) + response = client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = monitoring.ListFindingSummariesRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListFindingSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_finding_summaries_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = monitoring.ListFindingSummariesRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_finding_summaries(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == monitoring.ListFindingSummariesRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + +def test_list_finding_summaries_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_finding_summaries + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_finding_summaries + ] = mock_rpc + request = {} + client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_finding_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_finding_summaries_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.list_finding_summaries + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.list_finding_summaries + ] = mock_rpc + + request = {} + await client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.list_finding_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_finding_summaries_async( + transport: str = "grpc_asyncio", request_type=monitoring.ListFindingSummariesRequest +): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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_finding_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFindingSummariesResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = monitoring.ListFindingSummariesRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListFindingSummariesAsyncPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.asyncio +async def test_list_finding_summaries_async_from_dict(): + await test_list_finding_summaries_async(request_type=dict) + + +def test_list_finding_summaries_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.ListFindingSummariesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + call.return_value = monitoring.ListFindingSummariesResponse() + client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_finding_summaries_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.ListFindingSummariesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFindingSummariesResponse() + ) + await client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_list_finding_summaries_flattened(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListFindingSummariesResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_finding_summaries( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +def test_list_finding_summaries_flattened_error(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_finding_summaries( + monitoring.ListFindingSummariesRequest(), + parent="parent_value", + ) + + +@pytest.mark.asyncio +async def test_list_finding_summaries_flattened_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListFindingSummariesResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFindingSummariesResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_finding_summaries( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_list_finding_summaries_flattened_error_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.list_finding_summaries( + monitoring.ListFindingSummariesRequest(), + parent="parent_value", + ) + + +def test_list_finding_summaries_pager(transport_name: str = "grpc"): + client = MonitoringClient( + 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_finding_summaries), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[], + next_page_token="def", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + ), + RuntimeError, + ) + + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_finding_summaries(request={}, retry=retry, timeout=timeout) + + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, monitoring.FindingSummary) for i in results) + + +def test_list_finding_summaries_pages(transport_name: str = "grpc"): + client = MonitoringClient( + 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_finding_summaries), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[], + next_page_token="def", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + ), + RuntimeError, + ) + pages = list(client.list_finding_summaries(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_finding_summaries_async_pager(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[], + next_page_token="def", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + ), + RuntimeError, + ) + async_pager = await client.list_finding_summaries( + 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, monitoring.FindingSummary) for i in responses) + + +@pytest.mark.asyncio +async def test_list_finding_summaries_async_pages(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[], + next_page_token="def", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + ), + 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_finding_summaries(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", + [ + monitoring.FetchFrameworkComplianceReportRequest, + dict, + ], +) +def test_fetch_framework_compliance_report(request_type, transport: str = "grpc"): + client = MonitoringClient( + 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.fetch_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.FrameworkComplianceReport( + framework="framework_value", + framework_description="framework_description_value", + framework_type=common.Framework.FrameworkType.BUILT_IN, + supported_cloud_providers=[common.CloudProvider.AWS], + framework_categories=[common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD], + framework_display_name="framework_display_name_value", + name="name_value", + major_revision_id=1811, + minor_revision_id=1823, + ) + response = client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = monitoring.FetchFrameworkComplianceReportRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, monitoring.FrameworkComplianceReport) + assert response.framework == "framework_value" + assert response.framework_description == "framework_description_value" + assert response.framework_type == common.Framework.FrameworkType.BUILT_IN + assert response.supported_cloud_providers == [common.CloudProvider.AWS] + assert response.framework_categories == [ + common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD + ] + assert response.framework_display_name == "framework_display_name_value" + assert response.name == "name_value" + assert response.major_revision_id == 1811 + assert response.minor_revision_id == 1823 + + +def test_fetch_framework_compliance_report_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = monitoring.FetchFrameworkComplianceReportRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.fetch_framework_compliance_report(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == monitoring.FetchFrameworkComplianceReportRequest( + name="name_value", + ) + + +def test_fetch_framework_compliance_report_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.fetch_framework_compliance_report + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.fetch_framework_compliance_report + ] = mock_rpc + request = {} + client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.fetch_framework_compliance_report(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.fetch_framework_compliance_report + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.fetch_framework_compliance_report + ] = mock_rpc + + request = {} + await client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.fetch_framework_compliance_report(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_async( + transport: str = "grpc_asyncio", + request_type=monitoring.FetchFrameworkComplianceReportRequest, +): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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.fetch_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.FrameworkComplianceReport( + framework="framework_value", + framework_description="framework_description_value", + framework_type=common.Framework.FrameworkType.BUILT_IN, + supported_cloud_providers=[common.CloudProvider.AWS], + framework_categories=[ + common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD + ], + framework_display_name="framework_display_name_value", + name="name_value", + major_revision_id=1811, + minor_revision_id=1823, + ) + ) + response = await client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = monitoring.FetchFrameworkComplianceReportRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, monitoring.FrameworkComplianceReport) + assert response.framework == "framework_value" + assert response.framework_description == "framework_description_value" + assert response.framework_type == common.Framework.FrameworkType.BUILT_IN + assert response.supported_cloud_providers == [common.CloudProvider.AWS] + assert response.framework_categories == [ + common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD + ] + assert response.framework_display_name == "framework_display_name_value" + assert response.name == "name_value" + assert response.major_revision_id == 1811 + assert response.minor_revision_id == 1823 + + +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_async_from_dict(): + await test_fetch_framework_compliance_report_async(request_type=dict) + + +def test_fetch_framework_compliance_report_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.FetchFrameworkComplianceReportRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + call.return_value = monitoring.FrameworkComplianceReport() + client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.FetchFrameworkComplianceReportRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.FrameworkComplianceReport() + ) + await client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_fetch_framework_compliance_report_flattened(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.FrameworkComplianceReport() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.fetch_framework_compliance_report( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_fetch_framework_compliance_report_flattened_error(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.fetch_framework_compliance_report( + monitoring.FetchFrameworkComplianceReportRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_flattened_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.FrameworkComplianceReport() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.FrameworkComplianceReport() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.fetch_framework_compliance_report( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_flattened_error_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.fetch_framework_compliance_report( + monitoring.FetchFrameworkComplianceReportRequest(), + name="name_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.ListControlComplianceSummariesRequest, + dict, + ], +) +def test_list_control_compliance_summaries(request_type, transport: str = "grpc"): + client = MonitoringClient( + 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_control_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListControlComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + response = client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = monitoring.ListControlComplianceSummariesRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListControlComplianceSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_control_compliance_summaries_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = monitoring.ListControlComplianceSummariesRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_control_compliance_summaries(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == monitoring.ListControlComplianceSummariesRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + +def test_list_control_compliance_summaries_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_control_compliance_summaries + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_control_compliance_summaries + ] = mock_rpc + request = {} + client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_control_compliance_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.list_control_compliance_summaries + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.list_control_compliance_summaries + ] = mock_rpc + + request = {} + await client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.list_control_compliance_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_async( + transport: str = "grpc_asyncio", + request_type=monitoring.ListControlComplianceSummariesRequest, +): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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_control_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListControlComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = monitoring.ListControlComplianceSummariesRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListControlComplianceSummariesAsyncPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_async_from_dict(): + await test_list_control_compliance_summaries_async(request_type=dict) + + +def test_list_control_compliance_summaries_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.ListControlComplianceSummariesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + call.return_value = monitoring.ListControlComplianceSummariesResponse() + client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.ListControlComplianceSummariesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListControlComplianceSummariesResponse() + ) + await client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_list_control_compliance_summaries_flattened(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListControlComplianceSummariesResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_control_compliance_summaries( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +def test_list_control_compliance_summaries_flattened_error(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_control_compliance_summaries( + monitoring.ListControlComplianceSummariesRequest(), + parent="parent_value", + ) + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_flattened_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.ListControlComplianceSummariesResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListControlComplianceSummariesResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_control_compliance_summaries( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_flattened_error_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.list_control_compliance_summaries( + monitoring.ListControlComplianceSummariesRequest(), + parent="parent_value", + ) + + +def test_list_control_compliance_summaries_pager(transport_name: str = "grpc"): + client = MonitoringClient( + 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_control_compliance_summaries), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + ), + RuntimeError, + ) + + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_control_compliance_summaries( + request={}, retry=retry, timeout=timeout + ) + + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, monitoring.ControlComplianceSummary) for i in results) + + +def test_list_control_compliance_summaries_pages(transport_name: str = "grpc"): + client = MonitoringClient( + 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_control_compliance_summaries), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + ), + RuntimeError, + ) + pages = list(client.list_control_compliance_summaries(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_control_compliance_summaries_async_pager(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + ), + RuntimeError, + ) + async_pager = await client.list_control_compliance_summaries( + 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, monitoring.ControlComplianceSummary) for i in responses + ) + + +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_async_pages(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + ), + 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_control_compliance_summaries(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", + [ + monitoring.AggregateFrameworkComplianceReportRequest, + dict, + ], +) +def test_aggregate_framework_compliance_report(request_type, transport: str = "grpc"): + client = MonitoringClient( + 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.aggregate_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.AggregateFrameworkComplianceReportResponse() + response = client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = monitoring.AggregateFrameworkComplianceReportRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, monitoring.AggregateFrameworkComplianceReportResponse) + + +def test_aggregate_framework_compliance_report_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = monitoring.AggregateFrameworkComplianceReportRequest( + name="name_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.aggregate_framework_compliance_report(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == monitoring.AggregateFrameworkComplianceReportRequest( + name="name_value", + filter="filter_value", + ) + + +def test_aggregate_framework_compliance_report_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.aggregate_framework_compliance_report + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.aggregate_framework_compliance_report + ] = mock_rpc + request = {} + client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.aggregate_framework_compliance_report(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.aggregate_framework_compliance_report + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.aggregate_framework_compliance_report + ] = mock_rpc + + request = {} + await client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.aggregate_framework_compliance_report(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_async( + transport: str = "grpc_asyncio", + request_type=monitoring.AggregateFrameworkComplianceReportRequest, +): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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.aggregate_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.AggregateFrameworkComplianceReportResponse() + ) + response = await client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = monitoring.AggregateFrameworkComplianceReportRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, monitoring.AggregateFrameworkComplianceReportResponse) + + +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_async_from_dict(): + await test_aggregate_framework_compliance_report_async(request_type=dict) + + +def test_aggregate_framework_compliance_report_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.AggregateFrameworkComplianceReportRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + call.return_value = monitoring.AggregateFrameworkComplianceReportResponse() + client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = monitoring.AggregateFrameworkComplianceReportRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.AggregateFrameworkComplianceReportResponse() + ) + await client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_aggregate_framework_compliance_report_flattened(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.AggregateFrameworkComplianceReportResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.aggregate_framework_compliance_report( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_aggregate_framework_compliance_report_flattened_error(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.aggregate_framework_compliance_report( + monitoring.AggregateFrameworkComplianceReportRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_flattened_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = monitoring.AggregateFrameworkComplianceReportResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.AggregateFrameworkComplianceReportResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.aggregate_framework_compliance_report( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_flattened_error_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.aggregate_framework_compliance_report( + monitoring.AggregateFrameworkComplianceReportRequest(), + name="name_value", + ) + + +def test_list_framework_compliance_summaries_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_framework_compliance_summaries + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_framework_compliance_summaries + ] = mock_rpc + + request = {} + client.list_framework_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_framework_compliance_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_framework_compliance_summaries_rest_required_fields( + request_type=monitoring.ListFrameworkComplianceSummariesRequest, +): + transport_class = transports.MonitoringRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_framework_compliance_summaries._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_framework_compliance_summaries._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 = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = monitoring.ListFrameworkComplianceSummariesResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.ListFrameworkComplianceSummariesResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_framework_compliance_summaries(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_framework_compliance_summaries_rest_unset_required_fields(): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = ( + transport.list_framework_compliance_summaries._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_framework_compliance_summaries_rest_flattened(): + client = MonitoringClient( + 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 = monitoring.ListFrameworkComplianceSummariesResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "organizations/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = monitoring.ListFrameworkComplianceSummariesResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.list_framework_compliance_summaries(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=organizations/*/locations/*}/frameworkComplianceSummaries" + % client.transport._host, + args[1], + ) + + +def test_list_framework_compliance_summaries_rest_flattened_error( + transport: str = "rest", +): + client = MonitoringClient( + 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_framework_compliance_summaries( + monitoring.ListFrameworkComplianceSummariesRequest(), + parent="parent_value", + ) + + +def test_list_framework_compliance_summaries_rest_pager(transport: str = "rest"): + client = MonitoringClient( + 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 = ( + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFrameworkComplianceSummariesResponse( + framework_compliance_summaries=[ + monitoring.FrameworkComplianceSummary(), + monitoring.FrameworkComplianceSummary(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + monitoring.ListFrameworkComplianceSummariesResponse.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": "organizations/sample1/locations/sample2"} + + pager = client.list_framework_compliance_summaries(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, monitoring.FrameworkComplianceSummary) for i in results + ) + + pages = list( + client.list_framework_compliance_summaries(request=sample_request).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_list_finding_summaries_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_finding_summaries + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_finding_summaries + ] = mock_rpc + + request = {} + client.list_finding_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_finding_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_finding_summaries_rest_required_fields( + request_type=monitoring.ListFindingSummariesRequest, +): + transport_class = transports.MonitoringRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_finding_summaries._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_finding_summaries._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "end_time", + "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 = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = monitoring.ListFindingSummariesResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.ListFindingSummariesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_finding_summaries(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_finding_summaries_rest_unset_required_fields(): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_finding_summaries._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "endTime", + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_finding_summaries_rest_flattened(): + client = MonitoringClient( + 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 = monitoring.ListFindingSummariesResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "organizations/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = monitoring.ListFindingSummariesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.list_finding_summaries(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=organizations/*/locations/*}/findingSummaries" + % client.transport._host, + args[1], + ) + + +def test_list_finding_summaries_rest_flattened_error(transport: str = "rest"): + client = MonitoringClient( + 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_finding_summaries( + monitoring.ListFindingSummariesRequest(), + parent="parent_value", + ) + + +def test_list_finding_summaries_rest_pager(transport: str = "rest"): + client = MonitoringClient( + 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 = ( + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + next_page_token="abc", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[], + next_page_token="def", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListFindingSummariesResponse( + finding_summaries=[ + monitoring.FindingSummary(), + monitoring.FindingSummary(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + monitoring.ListFindingSummariesResponse.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": "organizations/sample1/locations/sample2"} + + pager = client.list_finding_summaries(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, monitoring.FindingSummary) for i in results) + + pages = list(client.list_finding_summaries(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_fetch_framework_compliance_report_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.fetch_framework_compliance_report + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.fetch_framework_compliance_report + ] = mock_rpc + + request = {} + client.fetch_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.fetch_framework_compliance_report(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_fetch_framework_compliance_report_rest_required_fields( + request_type=monitoring.FetchFrameworkComplianceReportRequest, +): + transport_class = transports.MonitoringRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).fetch_framework_compliance_report._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() + ).fetch_framework_compliance_report._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("end_time",)) + 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 = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = monitoring.FrameworkComplianceReport() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.FrameworkComplianceReport.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.fetch_framework_compliance_report(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_fetch_framework_compliance_report_rest_unset_required_fields(): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = ( + transport.fetch_framework_compliance_report._get_unset_required_fields({}) + ) + assert set(unset_fields) == (set(("endTime",)) & set(("name",))) + + +def test_fetch_framework_compliance_report_rest_flattened(): + client = MonitoringClient( + 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 = monitoring.FrameworkComplianceReport() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "organizations/sample1/locations/sample2/frameworkComplianceReports/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = monitoring.FrameworkComplianceReport.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.fetch_framework_compliance_report(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=organizations/*/locations/*/frameworkComplianceReports/*}:fetch" + % client.transport._host, + args[1], + ) + + +def test_fetch_framework_compliance_report_rest_flattened_error( + transport: str = "rest", +): + client = MonitoringClient( + 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.fetch_framework_compliance_report( + monitoring.FetchFrameworkComplianceReportRequest(), + name="name_value", + ) + + +def test_list_control_compliance_summaries_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_control_compliance_summaries + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_control_compliance_summaries + ] = mock_rpc + + request = {} + client.list_control_compliance_summaries(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_control_compliance_summaries(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_control_compliance_summaries_rest_required_fields( + request_type=monitoring.ListControlComplianceSummariesRequest, +): + transport_class = transports.MonitoringRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_control_compliance_summaries._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_control_compliance_summaries._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "end_time", + "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 = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = monitoring.ListControlComplianceSummariesResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.ListControlComplianceSummariesResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_control_compliance_summaries(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_control_compliance_summaries_rest_unset_required_fields(): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = ( + transport.list_control_compliance_summaries._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set( + ( + "endTime", + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_control_compliance_summaries_rest_flattened(): + client = MonitoringClient( + 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 = monitoring.ListControlComplianceSummariesResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 + # Convert return value to protobuf type + return_value = monitoring.ListControlComplianceSummariesResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.list_control_compliance_summaries(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=organizations/*/locations/*/frameworkComplianceReports/*}/controlComplianceSummaries" + % client.transport._host, + args[1], + ) + + +def test_list_control_compliance_summaries_rest_flattened_error( + transport: str = "rest", +): + client = MonitoringClient( + 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_control_compliance_summaries( + monitoring.ListControlComplianceSummariesRequest(), + parent="parent_value", + ) + + +def test_list_control_compliance_summaries_rest_pager(transport: str = "rest"): + client = MonitoringClient( + 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 = ( + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + next_page_token="abc", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[], + next_page_token="def", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + ], + next_page_token="ghi", + ), + monitoring.ListControlComplianceSummariesResponse( + control_compliance_summaries=[ + monitoring.ControlComplianceSummary(), + monitoring.ControlComplianceSummary(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + monitoring.ListControlComplianceSummariesResponse.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": "organizations/sample1/locations/sample2/frameworkComplianceReports/sample3" + } + + pager = client.list_control_compliance_summaries(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, monitoring.ControlComplianceSummary) for i in results) + + pages = list( + client.list_control_compliance_summaries(request=sample_request).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_aggregate_framework_compliance_report_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.aggregate_framework_compliance_report + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.aggregate_framework_compliance_report + ] = mock_rpc + + request = {} + client.aggregate_framework_compliance_report(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.aggregate_framework_compliance_report(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_aggregate_framework_compliance_report_rest_required_fields( + request_type=monitoring.AggregateFrameworkComplianceReportRequest, +): + transport_class = transports.MonitoringRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).aggregate_framework_compliance_report._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() + ).aggregate_framework_compliance_report._get_unset_required_fields( + jsonified_request + ) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "interval", + ) + ) + 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 = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = monitoring.AggregateFrameworkComplianceReportResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.AggregateFrameworkComplianceReportResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.aggregate_framework_compliance_report(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_aggregate_framework_compliance_report_rest_unset_required_fields(): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = ( + transport.aggregate_framework_compliance_report._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set( + ( + "filter", + "interval", + ) + ) + & set(("name",)) + ) + + +def test_aggregate_framework_compliance_report_rest_flattened(): + client = MonitoringClient( + 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 = monitoring.AggregateFrameworkComplianceReportResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "organizations/sample1/locations/sample2/frameworkComplianceReports/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = monitoring.AggregateFrameworkComplianceReportResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.aggregate_framework_compliance_report(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=organizations/*/locations/*/frameworkComplianceReports/*}:aggregate" + % client.transport._host, + args[1], + ) + + +def test_aggregate_framework_compliance_report_rest_flattened_error( + transport: str = "rest", +): + client = MonitoringClient( + 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.aggregate_framework_compliance_report( + monitoring.AggregateFrameworkComplianceReportRequest(), + name="name_value", + ) + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.MonitoringGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.MonitoringGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = MonitoringClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide an api_key and a transport instance. + transport = transports.MonitoringGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = MonitoringClient( + client_options=options, + transport=transport, + ) + + # It is an error to provide an api_key and a credential. + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = MonitoringClient( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.MonitoringGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = MonitoringClient( + client_options={"scopes": ["1", "2"]}, + transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.MonitoringGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = MonitoringClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.MonitoringGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.MonitoringGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.MonitoringGrpcTransport, + transports.MonitoringGrpcAsyncIOTransport, + transports.MonitoringRestTransport, + ], +) +def test_transport_adc(transport_class): + # Test default credentials are used if not provided. + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class() + adc.assert_called_once() + + +def test_transport_kind_grpc(): + transport = MonitoringClient.get_transport_class("grpc")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "grpc" + + +def test_initialize_client_w_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc" + ) + assert client is not None + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_framework_compliance_summaries_empty_call_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + call.return_value = monitoring.ListFrameworkComplianceSummariesResponse() + client.list_framework_compliance_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListFrameworkComplianceSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_finding_summaries_empty_call_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + call.return_value = monitoring.ListFindingSummariesResponse() + client.list_finding_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListFindingSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_fetch_framework_compliance_report_empty_call_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + call.return_value = monitoring.FrameworkComplianceReport() + client.fetch_framework_compliance_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.FetchFrameworkComplianceReportRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_control_compliance_summaries_empty_call_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + call.return_value = monitoring.ListControlComplianceSummariesResponse() + client.list_control_compliance_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListControlComplianceSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_aggregate_framework_compliance_report_empty_call_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + call.return_value = monitoring.AggregateFrameworkComplianceReportResponse() + client.aggregate_framework_compliance_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.AggregateFrameworkComplianceReportRequest() + + assert args[0] == request_msg + + +def test_transport_kind_grpc_asyncio(): + transport = MonitoringAsyncClient.get_transport_class("grpc_asyncio")( + credentials=async_anonymous_credentials() + ) + assert transport.kind == "grpc_asyncio" + + +def test_initialize_client_w_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), transport="grpc_asyncio" + ) + assert client is not None + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_list_framework_compliance_summaries_empty_call_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFrameworkComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_framework_compliance_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListFrameworkComplianceSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_list_finding_summaries_empty_call_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListFindingSummariesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_finding_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListFindingSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_fetch_framework_compliance_report_empty_call_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.FrameworkComplianceReport( + framework="framework_value", + framework_description="framework_description_value", + framework_type=common.Framework.FrameworkType.BUILT_IN, + supported_cloud_providers=[common.CloudProvider.AWS], + framework_categories=[ + common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD + ], + framework_display_name="framework_display_name_value", + name="name_value", + major_revision_id=1811, + minor_revision_id=1823, + ) + ) + await client.fetch_framework_compliance_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.FetchFrameworkComplianceReportRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_list_control_compliance_summaries_empty_call_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.ListControlComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_control_compliance_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListControlComplianceSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_aggregate_framework_compliance_report_empty_call_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + monitoring.AggregateFrameworkComplianceReportResponse() + ) + await client.aggregate_framework_compliance_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.AggregateFrameworkComplianceReportRequest() + + assert args[0] == request_msg + + +def test_transport_kind_rest(): + transport = MonitoringClient.get_transport_class("rest")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "rest" + + +def test_list_framework_compliance_summaries_rest_bad_request( + request_type=monitoring.ListFrameworkComplianceSummariesRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_framework_compliance_summaries(request) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.ListFrameworkComplianceSummariesRequest, + dict, + ], +) +def test_list_framework_compliance_summaries_rest_call_success(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = monitoring.ListFrameworkComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.ListFrameworkComplianceSummariesResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.list_framework_compliance_summaries(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListFrameworkComplianceSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_framework_compliance_summaries_rest_interceptors(null_interceptor): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MonitoringRestInterceptor(), + ) + client = MonitoringClient(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.MonitoringRestInterceptor, "post_list_framework_compliance_summaries" + ) as post, mock.patch.object( + transports.MonitoringRestInterceptor, + "post_list_framework_compliance_summaries_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MonitoringRestInterceptor, "pre_list_framework_compliance_summaries" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = monitoring.ListFrameworkComplianceSummariesRequest.pb( + monitoring.ListFrameworkComplianceSummariesRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = monitoring.ListFrameworkComplianceSummariesResponse.to_json( + monitoring.ListFrameworkComplianceSummariesResponse() + ) + req.return_value.content = return_value + + request = monitoring.ListFrameworkComplianceSummariesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = monitoring.ListFrameworkComplianceSummariesResponse() + post_with_metadata.return_value = ( + monitoring.ListFrameworkComplianceSummariesResponse(), + metadata, + ) + + client.list_framework_compliance_summaries( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_finding_summaries_rest_bad_request( + request_type=monitoring.ListFindingSummariesRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_finding_summaries(request) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.ListFindingSummariesRequest, + dict, + ], +) +def test_list_finding_summaries_rest_call_success(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = monitoring.ListFindingSummariesResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.ListFindingSummariesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.list_finding_summaries(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListFindingSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_finding_summaries_rest_interceptors(null_interceptor): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MonitoringRestInterceptor(), + ) + client = MonitoringClient(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.MonitoringRestInterceptor, "post_list_finding_summaries" + ) as post, mock.patch.object( + transports.MonitoringRestInterceptor, + "post_list_finding_summaries_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MonitoringRestInterceptor, "pre_list_finding_summaries" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = monitoring.ListFindingSummariesRequest.pb( + monitoring.ListFindingSummariesRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = monitoring.ListFindingSummariesResponse.to_json( + monitoring.ListFindingSummariesResponse() + ) + req.return_value.content = return_value + + request = monitoring.ListFindingSummariesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = monitoring.ListFindingSummariesResponse() + post_with_metadata.return_value = ( + monitoring.ListFindingSummariesResponse(), + metadata, + ) + + client.list_finding_summaries( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_fetch_framework_compliance_report_rest_bad_request( + request_type=monitoring.FetchFrameworkComplianceReportRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.fetch_framework_compliance_report(request) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.FetchFrameworkComplianceReportRequest, + dict, + ], +) +def test_fetch_framework_compliance_report_rest_call_success(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 = monitoring.FrameworkComplianceReport( + framework="framework_value", + framework_description="framework_description_value", + framework_type=common.Framework.FrameworkType.BUILT_IN, + supported_cloud_providers=[common.CloudProvider.AWS], + framework_categories=[common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD], + framework_display_name="framework_display_name_value", + name="name_value", + major_revision_id=1811, + minor_revision_id=1823, + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.FrameworkComplianceReport.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.fetch_framework_compliance_report(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, monitoring.FrameworkComplianceReport) + assert response.framework == "framework_value" + assert response.framework_description == "framework_description_value" + assert response.framework_type == common.Framework.FrameworkType.BUILT_IN + assert response.supported_cloud_providers == [common.CloudProvider.AWS] + assert response.framework_categories == [ + common.FrameworkCategory.INDUSTRY_DEFINED_STANDARD + ] + assert response.framework_display_name == "framework_display_name_value" + assert response.name == "name_value" + assert response.major_revision_id == 1811 + assert response.minor_revision_id == 1823 + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_fetch_framework_compliance_report_rest_interceptors(null_interceptor): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MonitoringRestInterceptor(), + ) + client = MonitoringClient(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.MonitoringRestInterceptor, "post_fetch_framework_compliance_report" + ) as post, mock.patch.object( + transports.MonitoringRestInterceptor, + "post_fetch_framework_compliance_report_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MonitoringRestInterceptor, "pre_fetch_framework_compliance_report" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = monitoring.FetchFrameworkComplianceReportRequest.pb( + monitoring.FetchFrameworkComplianceReportRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = monitoring.FrameworkComplianceReport.to_json( + monitoring.FrameworkComplianceReport() + ) + req.return_value.content = return_value + + request = monitoring.FetchFrameworkComplianceReportRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = monitoring.FrameworkComplianceReport() + post_with_metadata.return_value = ( + monitoring.FrameworkComplianceReport(), + metadata, + ) + + client.fetch_framework_compliance_report( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_control_compliance_summaries_rest_bad_request( + request_type=monitoring.ListControlComplianceSummariesRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "parent": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_control_compliance_summaries(request) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.ListControlComplianceSummariesRequest, + dict, + ], +) +def test_list_control_compliance_summaries_rest_call_success(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 = monitoring.ListControlComplianceSummariesResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.ListControlComplianceSummariesResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.list_control_compliance_summaries(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListControlComplianceSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_control_compliance_summaries_rest_interceptors(null_interceptor): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MonitoringRestInterceptor(), + ) + client = MonitoringClient(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.MonitoringRestInterceptor, "post_list_control_compliance_summaries" + ) as post, mock.patch.object( + transports.MonitoringRestInterceptor, + "post_list_control_compliance_summaries_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MonitoringRestInterceptor, "pre_list_control_compliance_summaries" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = monitoring.ListControlComplianceSummariesRequest.pb( + monitoring.ListControlComplianceSummariesRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = monitoring.ListControlComplianceSummariesResponse.to_json( + monitoring.ListControlComplianceSummariesResponse() + ) + req.return_value.content = return_value + + request = monitoring.ListControlComplianceSummariesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = monitoring.ListControlComplianceSummariesResponse() + post_with_metadata.return_value = ( + monitoring.ListControlComplianceSummariesResponse(), + metadata, + ) + + client.list_control_compliance_summaries( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_aggregate_framework_compliance_report_rest_bad_request( + request_type=monitoring.AggregateFrameworkComplianceReportRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.aggregate_framework_compliance_report(request) + + +@pytest.mark.parametrize( + "request_type", + [ + monitoring.AggregateFrameworkComplianceReportRequest, + dict, + ], +) +def test_aggregate_framework_compliance_report_rest_call_success(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/frameworkComplianceReports/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 = monitoring.AggregateFrameworkComplianceReportResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = monitoring.AggregateFrameworkComplianceReportResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.aggregate_framework_compliance_report(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, monitoring.AggregateFrameworkComplianceReportResponse) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_aggregate_framework_compliance_report_rest_interceptors(null_interceptor): + transport = transports.MonitoringRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.MonitoringRestInterceptor(), + ) + client = MonitoringClient(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.MonitoringRestInterceptor, + "post_aggregate_framework_compliance_report", + ) as post, mock.patch.object( + transports.MonitoringRestInterceptor, + "post_aggregate_framework_compliance_report_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.MonitoringRestInterceptor, + "pre_aggregate_framework_compliance_report", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = monitoring.AggregateFrameworkComplianceReportRequest.pb( + monitoring.AggregateFrameworkComplianceReportRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = monitoring.AggregateFrameworkComplianceReportResponse.to_json( + monitoring.AggregateFrameworkComplianceReportResponse() + ) + req.return_value.content = return_value + + request = monitoring.AggregateFrameworkComplianceReportRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = monitoring.AggregateFrameworkComplianceReportResponse() + post_with_metadata.return_value = ( + monitoring.AggregateFrameworkComplianceReportResponse(), + metadata, + ) + + client.aggregate_framework_compliance_report( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_location_rest_bad_request(request_type=locations_pb2.GetLocationRequest): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "organizations/sample1/locations/sample2"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_location(request) + + +@pytest.mark.parametrize( + "request_type", + [ + locations_pb2.GetLocationRequest, + dict, + ], +) +def test_get_location_rest(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = locations_pb2.Location() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_location(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.Location) + + +def test_list_locations_rest_bad_request( + request_type=locations_pb2.ListLocationsRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict({"name": "organizations/sample1"}, request) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_locations(request) + + +@pytest.mark.parametrize( + "request_type", + [ + locations_pb2.ListLocationsRequest, + dict, + ], +) +def test_list_locations_rest(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "organizations/sample1"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = locations_pb2.ListLocationsResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_locations(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.ListLocationsResponse) + + +def test_cancel_operation_rest_bad_request( + request_type=operations_pb2.CancelOperationRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "organizations/sample1/locations/sample2/operations/sample3"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.cancel_operation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.CancelOperationRequest, + dict, + ], +) +def test_cancel_operation_rest(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = { + "name": "organizations/sample1/locations/sample2/operations/sample3" + } + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = "{}" + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.cancel_operation(request) + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_operation_rest_bad_request( + request_type=operations_pb2.DeleteOperationRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "organizations/sample1/locations/sample2/operations/sample3"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.delete_operation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.DeleteOperationRequest, + dict, + ], +) +def test_delete_operation_rest(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = { + "name": "organizations/sample1/locations/sample2/operations/sample3" + } + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = "{}" + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.delete_operation(request) + + # Establish that the response is the type that we expect. + assert response is None + + +def test_get_operation_rest_bad_request( + request_type=operations_pb2.GetOperationRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "organizations/sample1/locations/sample2/operations/sample3"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_operation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.GetOperationRequest, + dict, + ], +) +def test_get_operation_rest(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = { + "name": "organizations/sample1/locations/sample2/operations/sample3" + } + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_operation(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.Operation) + + +def test_list_operations_rest_bad_request( + request_type=operations_pb2.ListOperationsRequest, +): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "organizations/sample1/locations/sample2"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_operations(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.ListOperationsRequest, + dict, + ], +) +def test_list_operations_rest(request_type): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.ListOperationsResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_operations(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.ListOperationsResponse) + + +def test_initialize_client_w_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + assert client is not None + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_framework_compliance_summaries_empty_call_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_framework_compliance_summaries), "__call__" + ) as call: + client.list_framework_compliance_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListFrameworkComplianceSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_finding_summaries_empty_call_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_finding_summaries), "__call__" + ) as call: + client.list_finding_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListFindingSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_fetch_framework_compliance_report_empty_call_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.fetch_framework_compliance_report), "__call__" + ) as call: + client.fetch_framework_compliance_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.FetchFrameworkComplianceReportRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_control_compliance_summaries_empty_call_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_control_compliance_summaries), "__call__" + ) as call: + client.list_control_compliance_summaries(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.ListControlComplianceSummariesRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_aggregate_framework_compliance_report_empty_call_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.aggregate_framework_compliance_report), "__call__" + ) as call: + client.aggregate_framework_compliance_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = monitoring.AggregateFrameworkComplianceReportRequest() + + assert args[0] == request_msg + + +def test_transport_grpc_default(): + # A client should use the gRPC transport by default. + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert isinstance( + client.transport, + transports.MonitoringGrpcTransport, + ) + + +def test_monitoring_base_transport_error(): + # Passing both a credentials object and credentials_file should raise an error + with pytest.raises(core_exceptions.DuplicateCredentialArgs): + transport = transports.MonitoringTransport( + credentials=ga_credentials.AnonymousCredentials(), + credentials_file="credentials.json", + ) + + +def test_monitoring_base_transport(): + # Instantiate the base transport. + with mock.patch( + "google.cloud.cloudsecuritycompliance_v1.services.monitoring.transports.MonitoringTransport.__init__" + ) as Transport: + Transport.return_value = None + transport = transports.MonitoringTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Every method on the transport should just blindly + # raise NotImplementedError. + methods = ( + "list_framework_compliance_summaries", + "list_finding_summaries", + "fetch_framework_compliance_report", + "list_control_compliance_summaries", + "aggregate_framework_compliance_report", + "get_location", + "list_locations", + "get_operation", + "cancel_operation", + "delete_operation", + "list_operations", + ) + for method in methods: + with pytest.raises(NotImplementedError): + getattr(transport, method)(request=object()) + + with pytest.raises(NotImplementedError): + transport.close() + + # Catch all for all remaining methods and properties + remainder = [ + "kind", + ] + for r in remainder: + with pytest.raises(NotImplementedError): + getattr(transport, r)() + + +def test_monitoring_base_transport_with_credentials_file(): + # Instantiate the base transport with a credentials file + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch( + "google.cloud.cloudsecuritycompliance_v1.services.monitoring.transports.MonitoringTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.MonitoringTransport( + credentials_file="credentials.json", + quota_project_id="octopus", + ) + load_creds.assert_called_once_with( + "credentials.json", + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +def test_monitoring_base_transport_with_adc(): + # Test the default credentials are used if credentials and credentials_file are None. + with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch( + "google.cloud.cloudsecuritycompliance_v1.services.monitoring.transports.MonitoringTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.MonitoringTransport() + adc.assert_called_once() + + +def test_monitoring_auth_adc(): + # If no credentials are provided, we should use ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + MonitoringClient() + adc.assert_called_once_with( + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id=None, + ) + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.MonitoringGrpcTransport, + transports.MonitoringGrpcAsyncIOTransport, + ], +) +def test_monitoring_transport_auth_adc(transport_class): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class(quota_project_id="octopus", scopes=["1", "2"]) + adc.assert_called_once_with( + scopes=["1", "2"], + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.MonitoringGrpcTransport, + transports.MonitoringGrpcAsyncIOTransport, + transports.MonitoringRestTransport, + ], +) +def test_monitoring_transport_auth_gdch_credentials(transport_class): + host = "https://language.com" + api_audience_tests = [None, "https://language2.com"] + api_audience_expect = [host, "https://language2.com"] + for t, e in zip(api_audience_tests, api_audience_expect): + with mock.patch.object(google.auth, "default", autospec=True) as adc: + gdch_mock = mock.MagicMock() + type(gdch_mock).with_gdch_audience = mock.PropertyMock( + return_value=gdch_mock + ) + adc.return_value = (gdch_mock, None) + transport_class(host=host, api_audience=t) + gdch_mock.with_gdch_audience.assert_called_once_with(e) + + +@pytest.mark.parametrize( + "transport_class,grpc_helpers", + [ + (transports.MonitoringGrpcTransport, grpc_helpers), + (transports.MonitoringGrpcAsyncIOTransport, grpc_helpers_async), + ], +) +def test_monitoring_transport_create_channel(transport_class, grpc_helpers): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object( + google.auth, "default", autospec=True + ) as adc, mock.patch.object( + grpc_helpers, "create_channel", autospec=True + ) as create_channel: + creds = ga_credentials.AnonymousCredentials() + adc.return_value = (creds, None) + transport_class(quota_project_id="octopus", scopes=["1", "2"]) + + create_channel.assert_called_with( + "cloudsecuritycompliance.googleapis.com:443", + credentials=creds, + credentials_file=None, + quota_project_id="octopus", + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + scopes=["1", "2"], + default_host="cloudsecuritycompliance.googleapis.com", + ssl_credentials=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + +@pytest.mark.parametrize( + "transport_class", + [transports.MonitoringGrpcTransport, transports.MonitoringGrpcAsyncIOTransport], +) +def test_monitoring_grpc_transport_client_cert_source_for_mtls(transport_class): + cred = ga_credentials.AnonymousCredentials() + + # Check ssl_channel_credentials is used if provided. + with mock.patch.object(transport_class, "create_channel") as mock_create_channel: + mock_ssl_channel_creds = mock.Mock() + transport_class( + host="squid.clam.whelk", + credentials=cred, + ssl_channel_credentials=mock_ssl_channel_creds, + ) + mock_create_channel.assert_called_once_with( + "squid.clam.whelk:443", + credentials=cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_channel_creds, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + # Check if ssl_channel_credentials is not provided, then client_cert_source_for_mtls + # is used. + with mock.patch.object(transport_class, "create_channel", return_value=mock.Mock()): + with mock.patch("grpc.ssl_channel_credentials") as mock_ssl_cred: + transport_class( + credentials=cred, + client_cert_source_for_mtls=client_cert_source_callback, + ) + expected_cert, expected_key = client_cert_source_callback() + mock_ssl_cred.assert_called_once_with( + certificate_chain=expected_cert, private_key=expected_key + ) + + +def test_monitoring_http_transport_client_cert_source_for_mtls(): + cred = ga_credentials.AnonymousCredentials() + with mock.patch( + "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel" + ) as mock_configure_mtls_channel: + transports.MonitoringRestTransport( + credentials=cred, client_cert_source_for_mtls=client_cert_source_callback + ) + mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback) + + +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + "rest", + ], +) +def test_monitoring_host_no_port(transport_name): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + client_options=client_options.ClientOptions( + api_endpoint="cloudsecuritycompliance.googleapis.com" + ), + transport=transport_name, + ) + assert client.transport._host == ( + "cloudsecuritycompliance.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://cloudsecuritycompliance.googleapis.com" + ) + + +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + "rest", + ], +) +def test_monitoring_host_with_port(transport_name): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + client_options=client_options.ClientOptions( + api_endpoint="cloudsecuritycompliance.googleapis.com:8000" + ), + transport=transport_name, + ) + assert client.transport._host == ( + "cloudsecuritycompliance.googleapis.com:8000" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://cloudsecuritycompliance.googleapis.com:8000" + ) + + +@pytest.mark.parametrize( + "transport_name", + [ + "rest", + ], +) +def test_monitoring_client_transport_session_collision(transport_name): + creds1 = ga_credentials.AnonymousCredentials() + creds2 = ga_credentials.AnonymousCredentials() + client1 = MonitoringClient( + credentials=creds1, + transport=transport_name, + ) + client2 = MonitoringClient( + credentials=creds2, + transport=transport_name, + ) + session1 = client1.transport.list_framework_compliance_summaries._session + session2 = client2.transport.list_framework_compliance_summaries._session + assert session1 != session2 + session1 = client1.transport.list_finding_summaries._session + session2 = client2.transport.list_finding_summaries._session + assert session1 != session2 + session1 = client1.transport.fetch_framework_compliance_report._session + session2 = client2.transport.fetch_framework_compliance_report._session + assert session1 != session2 + session1 = client1.transport.list_control_compliance_summaries._session + session2 = client2.transport.list_control_compliance_summaries._session + assert session1 != session2 + session1 = client1.transport.aggregate_framework_compliance_report._session + session2 = client2.transport.aggregate_framework_compliance_report._session + assert session1 != session2 + + +def test_monitoring_grpc_transport_channel(): + channel = grpc.secure_channel("http://localhost/", grpc.local_channel_credentials()) + + # Check that channel is used if provided. + transport = transports.MonitoringGrpcTransport( + host="squid.clam.whelk", + channel=channel, + ) + assert transport.grpc_channel == channel + assert transport._host == "squid.clam.whelk:443" + assert transport._ssl_channel_credentials == None + + +def test_monitoring_grpc_asyncio_transport_channel(): + channel = aio.secure_channel("http://localhost/", grpc.local_channel_credentials()) + + # Check that channel is used if provided. + transport = transports.MonitoringGrpcAsyncIOTransport( + host="squid.clam.whelk", + channel=channel, + ) + assert transport.grpc_channel == channel + assert transport._host == "squid.clam.whelk:443" + assert transport._ssl_channel_credentials == None + + +# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are +# removed from grpc/grpc_asyncio transport constructor. +@pytest.mark.parametrize( + "transport_class", + [transports.MonitoringGrpcTransport, transports.MonitoringGrpcAsyncIOTransport], +) +def test_monitoring_transport_channel_mtls_with_client_cert_source(transport_class): + with mock.patch( + "grpc.ssl_channel_credentials", autospec=True + ) as grpc_ssl_channel_cred: + with mock.patch.object( + transport_class, "create_channel" + ) as grpc_create_channel: + mock_ssl_cred = mock.Mock() + grpc_ssl_channel_cred.return_value = mock_ssl_cred + + mock_grpc_channel = mock.Mock() + grpc_create_channel.return_value = mock_grpc_channel + + cred = ga_credentials.AnonymousCredentials() + with pytest.warns(DeprecationWarning): + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (cred, None) + transport = transport_class( + host="squid.clam.whelk", + api_mtls_endpoint="mtls.squid.clam.whelk", + client_cert_source=client_cert_source_callback, + ) + adc.assert_called_once() + + grpc_ssl_channel_cred.assert_called_once_with( + certificate_chain=b"cert bytes", private_key=b"key bytes" + ) + grpc_create_channel.assert_called_once_with( + "mtls.squid.clam.whelk:443", + credentials=cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_cred, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + assert transport.grpc_channel == mock_grpc_channel + assert transport._ssl_channel_credentials == mock_ssl_cred + + +# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are +# removed from grpc/grpc_asyncio transport constructor. +@pytest.mark.parametrize( + "transport_class", + [transports.MonitoringGrpcTransport, transports.MonitoringGrpcAsyncIOTransport], +) +def test_monitoring_transport_channel_mtls_with_adc(transport_class): + mock_ssl_cred = mock.Mock() + with mock.patch.multiple( + "google.auth.transport.grpc.SslCredentials", + __init__=mock.Mock(return_value=None), + ssl_credentials=mock.PropertyMock(return_value=mock_ssl_cred), + ): + with mock.patch.object( + transport_class, "create_channel" + ) as grpc_create_channel: + mock_grpc_channel = mock.Mock() + grpc_create_channel.return_value = mock_grpc_channel + mock_cred = mock.Mock() + + with pytest.warns(DeprecationWarning): + transport = transport_class( + host="squid.clam.whelk", + credentials=mock_cred, + api_mtls_endpoint="mtls.squid.clam.whelk", + client_cert_source=None, + ) + + grpc_create_channel.assert_called_once_with( + "mtls.squid.clam.whelk:443", + credentials=mock_cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_cred, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + assert transport.grpc_channel == mock_grpc_channel + + +def test_control_compliance_summary_path(): + project = "squid" + location = "clam" + framework_compliance_report = "whelk" + control_compliance_summary = "octopus" + expected = "projects/{project}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}/controlComplianceSummaries/{control_compliance_summary}".format( + project=project, + location=location, + framework_compliance_report=framework_compliance_report, + control_compliance_summary=control_compliance_summary, + ) + actual = MonitoringClient.control_compliance_summary_path( + project, location, framework_compliance_report, control_compliance_summary + ) + assert expected == actual + + +def test_parse_control_compliance_summary_path(): + expected = { + "project": "oyster", + "location": "nudibranch", + "framework_compliance_report": "cuttlefish", + "control_compliance_summary": "mussel", + } + path = MonitoringClient.control_compliance_summary_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_control_compliance_summary_path(path) + assert expected == actual + + +def test_finding_summary_path(): + project = "winkle" + location = "nautilus" + finding_summary = "scallop" + expected = "projects/{project}/locations/{location}/findingSummaries/{finding_summary}".format( + project=project, + location=location, + finding_summary=finding_summary, + ) + actual = MonitoringClient.finding_summary_path(project, location, finding_summary) + assert expected == actual + + +def test_parse_finding_summary_path(): + expected = { + "project": "abalone", + "location": "squid", + "finding_summary": "clam", + } + path = MonitoringClient.finding_summary_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_finding_summary_path(path) + assert expected == actual + + +def test_framework_compliance_report_path(): + project = "whelk" + location = "octopus" + framework_compliance_report = "oyster" + expected = "projects/{project}/locations/{location}/frameworkComplianceReports/{framework_compliance_report}".format( + project=project, + location=location, + framework_compliance_report=framework_compliance_report, + ) + actual = MonitoringClient.framework_compliance_report_path( + project, location, framework_compliance_report + ) + assert expected == actual + + +def test_parse_framework_compliance_report_path(): + expected = { + "project": "nudibranch", + "location": "cuttlefish", + "framework_compliance_report": "mussel", + } + path = MonitoringClient.framework_compliance_report_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_framework_compliance_report_path(path) + assert expected == actual + + +def test_framework_compliance_summary_path(): + project = "winkle" + location = "nautilus" + framework_compliance_summary = "scallop" + expected = "projects/{project}/locations/{location}/frameworkComplianceSummaries/{framework_compliance_summary}".format( + project=project, + location=location, + framework_compliance_summary=framework_compliance_summary, + ) + actual = MonitoringClient.framework_compliance_summary_path( + project, location, framework_compliance_summary + ) + assert expected == actual + + +def test_parse_framework_compliance_summary_path(): + expected = { + "project": "abalone", + "location": "squid", + "framework_compliance_summary": "clam", + } + path = MonitoringClient.framework_compliance_summary_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_framework_compliance_summary_path(path) + assert expected == actual + + +def test_common_billing_account_path(): + billing_account = "whelk" + expected = "billingAccounts/{billing_account}".format( + billing_account=billing_account, + ) + actual = MonitoringClient.common_billing_account_path(billing_account) + assert expected == actual + + +def test_parse_common_billing_account_path(): + expected = { + "billing_account": "octopus", + } + path = MonitoringClient.common_billing_account_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_common_billing_account_path(path) + assert expected == actual + + +def test_common_folder_path(): + folder = "oyster" + expected = "folders/{folder}".format( + folder=folder, + ) + actual = MonitoringClient.common_folder_path(folder) + assert expected == actual + + +def test_parse_common_folder_path(): + expected = { + "folder": "nudibranch", + } + path = MonitoringClient.common_folder_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_common_folder_path(path) + assert expected == actual + + +def test_common_organization_path(): + organization = "cuttlefish" + expected = "organizations/{organization}".format( + organization=organization, + ) + actual = MonitoringClient.common_organization_path(organization) + assert expected == actual + + +def test_parse_common_organization_path(): + expected = { + "organization": "mussel", + } + path = MonitoringClient.common_organization_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_common_organization_path(path) + assert expected == actual + + +def test_common_project_path(): + project = "winkle" + expected = "projects/{project}".format( + project=project, + ) + actual = MonitoringClient.common_project_path(project) + assert expected == actual + + +def test_parse_common_project_path(): + expected = { + "project": "nautilus", + } + path = MonitoringClient.common_project_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_common_project_path(path) + assert expected == actual + + +def test_common_location_path(): + project = "scallop" + location = "abalone" + expected = "projects/{project}/locations/{location}".format( + project=project, + location=location, + ) + actual = MonitoringClient.common_location_path(project, location) + assert expected == actual + + +def test_parse_common_location_path(): + expected = { + "project": "squid", + "location": "clam", + } + path = MonitoringClient.common_location_path(**expected) + + # Check that the path construction is reversible. + actual = MonitoringClient.parse_common_location_path(path) + assert expected == actual + + +def test_client_with_default_client_info(): + client_info = gapic_v1.client_info.ClientInfo() + + with mock.patch.object( + transports.MonitoringTransport, "_prep_wrapped_messages" + ) as prep: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, + ) + prep.assert_called_once_with(client_info) + + with mock.patch.object( + transports.MonitoringTransport, "_prep_wrapped_messages" + ) as prep: + transport_class = MonitoringClient.get_transport_class() + transport = transport_class( + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, + ) + prep.assert_called_once_with(client_info) + + +def test_delete_operation(transport: str = "grpc"): + client = MonitoringClient( + 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 = operations_pb2.DeleteOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_delete_operation_async(transport: str = "grpc_asyncio"): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.DeleteOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_operation_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.DeleteOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + call.return_value = None + + client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_operation_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.DeleteOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_delete_operation_from_dict(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + + response = client.delete_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_delete_operation_from_dict_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_cancel_operation(transport: str = "grpc"): + client = MonitoringClient( + 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 = operations_pb2.CancelOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_cancel_operation_async(transport: str = "grpc_asyncio"): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.CancelOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_cancel_operation_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.CancelOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + call.return_value = None + + client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_cancel_operation_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.CancelOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_cancel_operation_from_dict(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + + response = client.cancel_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_cancel_operation_from_dict_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.cancel_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_get_operation(transport: str = "grpc"): + client = MonitoringClient( + 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 = operations_pb2.GetOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation() + response = client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.Operation) + + +@pytest.mark.asyncio +async def test_get_operation_async(transport: str = "grpc_asyncio"): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.GetOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation() + ) + response = await client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.Operation) + + +def test_get_operation_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.GetOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + call.return_value = operations_pb2.Operation() + + client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_operation_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.GetOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation() + ) + await client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_get_operation_from_dict(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation() + + response = client.get_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_get_operation_from_dict_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation() + ) + response = await client.get_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_list_operations(transport: str = "grpc"): + client = MonitoringClient( + 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 = operations_pb2.ListOperationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.ListOperationsResponse() + response = client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.ListOperationsResponse) + + +@pytest.mark.asyncio +async def test_list_operations_async(transport: str = "grpc_asyncio"): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.ListOperationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.ListOperationsResponse() + ) + response = await client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.ListOperationsResponse) + + +def test_list_operations_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.ListOperationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + call.return_value = operations_pb2.ListOperationsResponse() + + client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_operations_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.ListOperationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.ListOperationsResponse() + ) + await client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_list_operations_from_dict(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.ListOperationsResponse() + + response = client.list_operations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_list_operations_from_dict_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.ListOperationsResponse() + ) + response = await client.list_operations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_list_locations(transport: str = "grpc"): + client = MonitoringClient( + 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 = locations_pb2.ListLocationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.ListLocationsResponse() + response = client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.ListLocationsResponse) + + +@pytest.mark.asyncio +async def test_list_locations_async(transport: str = "grpc_asyncio"): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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 = locations_pb2.ListLocationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.ListLocationsResponse() + ) + response = await client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.ListLocationsResponse) + + +def test_list_locations_field_headers(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.ListLocationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + call.return_value = locations_pb2.ListLocationsResponse() + + client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_locations_field_headers_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.ListLocationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.ListLocationsResponse() + ) + await client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_list_locations_from_dict(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.ListLocationsResponse() + + response = client.list_locations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_list_locations_from_dict_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.ListLocationsResponse() + ) + response = await client.list_locations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_get_location(transport: str = "grpc"): + client = MonitoringClient( + 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 = locations_pb2.GetLocationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.Location() + response = client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.Location) + + +@pytest.mark.asyncio +async def test_get_location_async(transport: str = "grpc_asyncio"): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + 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 = locations_pb2.GetLocationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.Location() + ) + response = await client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.Location) + + +def test_get_location_field_headers(): + client = MonitoringClient(credentials=ga_credentials.AnonymousCredentials()) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.GetLocationRequest() + request.name = "locations/abc" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + call.return_value = locations_pb2.Location() + + client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations/abc", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_location_field_headers_async(): + client = MonitoringAsyncClient(credentials=async_anonymous_credentials()) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.GetLocationRequest() + request.name = "locations/abc" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.Location() + ) + await client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations/abc", + ) in kw["metadata"] + + +def test_get_location_from_dict(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.Location() + + response = client.get_location( + request={ + "name": "locations/abc", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_get_location_from_dict_async(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.Location() + ) + response = await client.get_location( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_transport_close_grpc(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc" + ) + with mock.patch.object( + type(getattr(client.transport, "_grpc_channel")), "close" + ) as close: + with client: + close.assert_not_called() + close.assert_called_once() + + +@pytest.mark.asyncio +async def test_transport_close_grpc_asyncio(): + client = MonitoringAsyncClient( + credentials=async_anonymous_credentials(), transport="grpc_asyncio" + ) + with mock.patch.object( + type(getattr(client.transport, "_grpc_channel")), "close" + ) as close: + async with client: + close.assert_not_called() + close.assert_called_once() + + +def test_transport_close_rest(): + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + with mock.patch.object( + type(getattr(client.transport, "_session")), "close" + ) as close: + with client: + close.assert_not_called() + close.assert_called_once() + + +def test_client_ctx(): + transports = [ + "rest", + "grpc", + ] + for transport in transports: + client = MonitoringClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport + ) + # Test client calls underlying transport. + with mock.patch.object(type(client.transport), "close") as close: + close.assert_not_called() + with client: + pass + close.assert_called() + + +@pytest.mark.parametrize( + "client_class,transport_class", + [ + (MonitoringClient, transports.MonitoringGrpcTransport), + (MonitoringAsyncClient, transports.MonitoringGrpcAsyncIOTransport), + ], +) +def test_api_key_credentials(client_class, transport_class): + with mock.patch.object( + google.auth._default, "get_api_key_credentials", create=True + ) as get_api_key_credentials: + mock_cred = mock.Mock() + get_api_key_credentials.return_value = mock_cred + options = client_options.ClientOptions() + options.api_key = "api_key" + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + patched.assert_called_once_with( + credentials=mock_cred, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) diff --git a/packages/google-cloud-network-management/.repo-metadata.json b/packages/google-cloud-network-management/.repo-metadata.json index b20dbd30043c..c3e5eef1bffe 100644 --- a/packages/google-cloud-network-management/.repo-metadata.json +++ b/packages/google-cloud-network-management/.repo-metadata.json @@ -1,16 +1,16 @@ { - "name": "networkmanagement", - "name_pretty": "Network Management", - "api_description": "provides a collection of network performance monitoring and diagnostic capabilities.", - "product_documentation": "https://cloud.google.com/network-management", - "client_documentation": "https://cloud.google.com/python/docs/reference/networkmanagement/latest", - "issue_tracker": "", - "release_level": "stable", - "language": "python", - "library_type": "GAPIC_AUTO", - "repo": "googleapis/google-cloud-python", - "distribution_name": "google-cloud-network-management", - "api_id": "networkmanagement.googleapis.com", - "default_version": "v1", - "api_shortname": "networkmanagement" -} \ No newline at end of file + "name": "google-cloud-network-management", + "name_pretty": "Network Management API", + "api_description": "The Network Management API provides a collection of network performance\nmonitoring and diagnostic capabilities.", + "product_documentation": "", + "client_documentation": "https://cloud.google.com/python/docs/reference/google-cloud-network-management/latest", + "issue_tracker": "https://github.com/googleapis/google-cloud-python/issues", + "release_level": "preview", + "language": "python", + "library_type": "GAPIC_AUTO", + "repo": "googleapis/google-cloud-python", + "distribution_name": "google-cloud-network-management", + "api_id": "networkmanagement.googleapis.com", + "default_version": "v1", + "api_shortname": "networkmanagement" +} diff --git a/packages/google-cloud-network-management/README.rst b/packages/google-cloud-network-management/README.rst index b23d48746fa8..f739b66acdc0 100644 --- a/packages/google-cloud-network-management/README.rst +++ b/packages/google-cloud-network-management/README.rst @@ -1,22 +1,23 @@ -Python Client for Network Management -==================================== +Python Client for Network Management API +======================================== -|stable| |pypi| |versions| +|preview| |pypi| |versions| -`Network Management`_: provides a collection of network performance monitoring and diagnostic capabilities. +`Network Management API`_: The Network Management API provides a collection of network performance +monitoring and diagnostic capabilities. - `Client Library Documentation`_ - `Product Documentation`_ -.. |stable| image:: https://img.shields.io/badge/support-stable-gold.svg +.. |preview| image:: https://img.shields.io/badge/support-preview-orange.svg :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#stability-levels .. |pypi| image:: https://img.shields.io/pypi/v/google-cloud-network-management.svg :target: https://pypi.org/project/google-cloud-network-management/ .. |versions| image:: https://img.shields.io/pypi/pyversions/google-cloud-network-management.svg :target: https://pypi.org/project/google-cloud-network-management/ -.. _Network Management: https://cloud.google.com/network-management -.. _Client Library Documentation: https://cloud.google.com/python/docs/reference/networkmanagement/latest/summary_overview -.. _Product Documentation: https://cloud.google.com/network-management +.. _Network Management API: +.. _Client Library Documentation: https://cloud.google.com/python/docs/reference/google-cloud-network-management/latest/summary_overview +.. _Product Documentation: Quick Start ----------- @@ -25,12 +26,12 @@ In order to use this library, you first need to go through the following steps: 1. `Select or create a Cloud Platform project.`_ 2. `Enable billing for your project.`_ -3. `Enable the Network Management.`_ +3. `Enable the Network Management API.`_ 4. `Set up Authentication.`_ .. _Select or create a Cloud Platform project.: https://console.cloud.google.com/project .. _Enable billing for your project.: https://cloud.google.com/billing/docs/how-to/modify-project#enable_billing_for_a_project -.. _Enable the Network Management.: https://cloud.google.com/network-management +.. _Enable the Network Management API.: .. _Set up Authentication.: https://googleapis.dev/python/google-api-core/latest/auth.html Installation @@ -97,14 +98,14 @@ Windows Next Steps ~~~~~~~~~~ -- Read the `Client Library Documentation`_ for Network Management +- Read the `Client Library Documentation`_ for Network Management API to see other available methods on the client. -- Read the `Network Management Product documentation`_ to learn +- Read the `Network Management API Product documentation`_ to learn more about the product and see How-to Guides. - View this `README`_ to see the full list of Cloud APIs that we cover. -.. _Network Management Product documentation: https://cloud.google.com/network-management +.. _Network Management API Product documentation: .. _README: https://github.com/googleapis/google-cloud-python/blob/main/README.rst Logging diff --git a/packages/google-cloud-network-management/docs/network_management_v1/organization_vpc_flow_logs_service.rst b/packages/google-cloud-network-management/docs/network_management_v1/organization_vpc_flow_logs_service.rst new file mode 100644 index 000000000000..ad70284c237f --- /dev/null +++ b/packages/google-cloud-network-management/docs/network_management_v1/organization_vpc_flow_logs_service.rst @@ -0,0 +1,10 @@ +OrganizationVpcFlowLogsService +------------------------------------------------ + +.. automodule:: google.cloud.network_management_v1.services.organization_vpc_flow_logs_service + :members: + :inherited-members: + +.. automodule:: google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.pagers + :members: + :inherited-members: diff --git a/packages/google-cloud-network-management/docs/network_management_v1/services_.rst b/packages/google-cloud-network-management/docs/network_management_v1/services_.rst index fc797859cd09..7b050e681b50 100644 --- a/packages/google-cloud-network-management/docs/network_management_v1/services_.rst +++ b/packages/google-cloud-network-management/docs/network_management_v1/services_.rst @@ -3,5 +3,6 @@ Services for Google Cloud Network Management v1 API .. toctree:: :maxdepth: 2 + organization_vpc_flow_logs_service reachability_service vpc_flow_logs_service diff --git a/packages/google-cloud-network-management/docs/summary_overview.md b/packages/google-cloud-network-management/docs/summary_overview.md index 68ecf8540d59..3d734594e7fb 100644 --- a/packages/google-cloud-network-management/docs/summary_overview.md +++ b/packages/google-cloud-network-management/docs/summary_overview.md @@ -5,18 +5,18 @@ reverted. Instead, if you want to place additional content, create an pick up on the content and merge the content. ]: # -# Network Management API +# Network Management API API -Overview of the APIs available for Network Management API. +Overview of the APIs available for Network Management API API. ## All entries Classes, methods and properties & attributes for -Network Management API. +Network Management API API. -[classes](https://cloud.google.com/python/docs/reference/networkmanagement/latest/summary_class.html) +[classes](https://cloud.google.com/python/docs/reference/google-cloud-network-management/latest/summary_class.html) -[methods](https://cloud.google.com/python/docs/reference/networkmanagement/latest/summary_method.html) +[methods](https://cloud.google.com/python/docs/reference/google-cloud-network-management/latest/summary_method.html) [properties and -attributes](https://cloud.google.com/python/docs/reference/networkmanagement/latest/summary_property.html) +attributes](https://cloud.google.com/python/docs/reference/google-cloud-network-management/latest/summary_property.html) diff --git a/packages/google-cloud-network-management/google/cloud/network_management/__init__.py b/packages/google-cloud-network-management/google/cloud/network_management/__init__.py index 17b37d168cb1..dd26414a5111 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management/__init__.py +++ b/packages/google-cloud-network-management/google/cloud/network_management/__init__.py @@ -18,6 +18,12 @@ __version__ = package_version.__version__ +from google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.async_client import ( + OrganizationVpcFlowLogsServiceAsyncClient, +) +from google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.client import ( + OrganizationVpcFlowLogsServiceClient, +) from google.cloud.network_management_v1.services.reachability_service.async_client import ( ReachabilityServiceAsyncClient, ) @@ -63,7 +69,9 @@ ForwardingRuleInfo, GKEMasterInfo, GoogleServiceInfo, + HybridSubnetInfo, InstanceInfo, + InterconnectAttachmentInfo, LoadBalancerBackend, LoadBalancerBackendInfo, LoadBalancerInfo, @@ -89,13 +97,20 @@ GetVpcFlowLogsConfigRequest, ListVpcFlowLogsConfigsRequest, ListVpcFlowLogsConfigsResponse, + QueryOrgVpcFlowLogsConfigsRequest, + QueryOrgVpcFlowLogsConfigsResponse, + ShowEffectiveFlowLogsConfigsRequest, + ShowEffectiveFlowLogsConfigsResponse, UpdateVpcFlowLogsConfigRequest, ) from google.cloud.network_management_v1.types.vpc_flow_logs_config import ( + EffectiveVpcFlowLogsConfig, VpcFlowLogsConfig, ) __all__ = ( + "OrganizationVpcFlowLogsServiceClient", + "OrganizationVpcFlowLogsServiceAsyncClient", "ReachabilityServiceClient", "ReachabilityServiceAsyncClient", "VpcFlowLogsServiceClient", @@ -128,7 +143,9 @@ "ForwardingRuleInfo", "GKEMasterInfo", "GoogleServiceInfo", + "HybridSubnetInfo", "InstanceInfo", + "InterconnectAttachmentInfo", "LoadBalancerBackend", "LoadBalancerBackendInfo", "LoadBalancerInfo", @@ -152,6 +169,11 @@ "GetVpcFlowLogsConfigRequest", "ListVpcFlowLogsConfigsRequest", "ListVpcFlowLogsConfigsResponse", + "QueryOrgVpcFlowLogsConfigsRequest", + "QueryOrgVpcFlowLogsConfigsResponse", + "ShowEffectiveFlowLogsConfigsRequest", + "ShowEffectiveFlowLogsConfigsResponse", "UpdateVpcFlowLogsConfigRequest", + "EffectiveVpcFlowLogsConfig", "VpcFlowLogsConfig", ) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/__init__.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/__init__.py index 8927caf475c3..fdf67817917e 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/__init__.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/__init__.py @@ -18,6 +18,10 @@ __version__ = package_version.__version__ +from .services.organization_vpc_flow_logs_service import ( + OrganizationVpcFlowLogsServiceAsyncClient, + OrganizationVpcFlowLogsServiceClient, +) from .services.reachability_service import ( ReachabilityServiceAsyncClient, ReachabilityServiceClient, @@ -59,7 +63,9 @@ ForwardingRuleInfo, GKEMasterInfo, GoogleServiceInfo, + HybridSubnetInfo, InstanceInfo, + InterconnectAttachmentInfo, LoadBalancerBackend, LoadBalancerBackendInfo, LoadBalancerInfo, @@ -85,11 +91,16 @@ GetVpcFlowLogsConfigRequest, ListVpcFlowLogsConfigsRequest, ListVpcFlowLogsConfigsResponse, + QueryOrgVpcFlowLogsConfigsRequest, + QueryOrgVpcFlowLogsConfigsResponse, + ShowEffectiveFlowLogsConfigsRequest, + ShowEffectiveFlowLogsConfigsResponse, UpdateVpcFlowLogsConfigRequest, ) -from .types.vpc_flow_logs_config import VpcFlowLogsConfig +from .types.vpc_flow_logs_config import EffectiveVpcFlowLogsConfig, VpcFlowLogsConfig __all__ = ( + "OrganizationVpcFlowLogsServiceAsyncClient", "ReachabilityServiceAsyncClient", "VpcFlowLogsServiceAsyncClient", "AbortInfo", @@ -105,6 +116,7 @@ "DeliverInfo", "DirectVpcEgressConnectionInfo", "DropInfo", + "EffectiveVpcFlowLogsConfig", "Endpoint", "EndpointInfo", "FirewallInfo", @@ -114,7 +126,9 @@ "GetConnectivityTestRequest", "GetVpcFlowLogsConfigRequest", "GoogleServiceInfo", + "HybridSubnetInfo", "InstanceInfo", + "InterconnectAttachmentInfo", "LatencyDistribution", "LatencyPercentile", "ListConnectivityTestsRequest", @@ -128,8 +142,11 @@ "NatInfo", "NetworkInfo", "OperationMetadata", + "OrganizationVpcFlowLogsServiceClient", "ProbingDetails", "ProxyConnectionInfo", + "QueryOrgVpcFlowLogsConfigsRequest", + "QueryOrgVpcFlowLogsConfigsResponse", "ReachabilityDetails", "ReachabilityServiceClient", "RedisClusterInfo", @@ -138,6 +155,8 @@ "RouteInfo", "ServerlessExternalConnectionInfo", "ServerlessNegInfo", + "ShowEffectiveFlowLogsConfigsRequest", + "ShowEffectiveFlowLogsConfigsResponse", "Step", "StorageBucketInfo", "Trace", diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/gapic_metadata.json b/packages/google-cloud-network-management/google/cloud/network_management_v1/gapic_metadata.json index 4f020eb70b02..723c9d95854d 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/gapic_metadata.json +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/gapic_metadata.json @@ -5,6 +5,100 @@ "protoPackage": "google.cloud.networkmanagement.v1", "schema": "1.0", "services": { + "OrganizationVpcFlowLogsService": { + "clients": { + "grpc": { + "libraryClient": "OrganizationVpcFlowLogsServiceClient", + "rpcs": { + "CreateVpcFlowLogsConfig": { + "methods": [ + "create_vpc_flow_logs_config" + ] + }, + "DeleteVpcFlowLogsConfig": { + "methods": [ + "delete_vpc_flow_logs_config" + ] + }, + "GetVpcFlowLogsConfig": { + "methods": [ + "get_vpc_flow_logs_config" + ] + }, + "ListVpcFlowLogsConfigs": { + "methods": [ + "list_vpc_flow_logs_configs" + ] + }, + "UpdateVpcFlowLogsConfig": { + "methods": [ + "update_vpc_flow_logs_config" + ] + } + } + }, + "grpc-async": { + "libraryClient": "OrganizationVpcFlowLogsServiceAsyncClient", + "rpcs": { + "CreateVpcFlowLogsConfig": { + "methods": [ + "create_vpc_flow_logs_config" + ] + }, + "DeleteVpcFlowLogsConfig": { + "methods": [ + "delete_vpc_flow_logs_config" + ] + }, + "GetVpcFlowLogsConfig": { + "methods": [ + "get_vpc_flow_logs_config" + ] + }, + "ListVpcFlowLogsConfigs": { + "methods": [ + "list_vpc_flow_logs_configs" + ] + }, + "UpdateVpcFlowLogsConfig": { + "methods": [ + "update_vpc_flow_logs_config" + ] + } + } + }, + "rest": { + "libraryClient": "OrganizationVpcFlowLogsServiceClient", + "rpcs": { + "CreateVpcFlowLogsConfig": { + "methods": [ + "create_vpc_flow_logs_config" + ] + }, + "DeleteVpcFlowLogsConfig": { + "methods": [ + "delete_vpc_flow_logs_config" + ] + }, + "GetVpcFlowLogsConfig": { + "methods": [ + "get_vpc_flow_logs_config" + ] + }, + "ListVpcFlowLogsConfigs": { + "methods": [ + "list_vpc_flow_logs_configs" + ] + }, + "UpdateVpcFlowLogsConfig": { + "methods": [ + "update_vpc_flow_logs_config" + ] + } + } + } + } + }, "ReachabilityService": { "clients": { "grpc": { @@ -139,6 +233,16 @@ "list_vpc_flow_logs_configs" ] }, + "QueryOrgVpcFlowLogsConfigs": { + "methods": [ + "query_org_vpc_flow_logs_configs" + ] + }, + "ShowEffectiveFlowLogsConfigs": { + "methods": [ + "show_effective_flow_logs_configs" + ] + }, "UpdateVpcFlowLogsConfig": { "methods": [ "update_vpc_flow_logs_config" @@ -169,6 +273,16 @@ "list_vpc_flow_logs_configs" ] }, + "QueryOrgVpcFlowLogsConfigs": { + "methods": [ + "query_org_vpc_flow_logs_configs" + ] + }, + "ShowEffectiveFlowLogsConfigs": { + "methods": [ + "show_effective_flow_logs_configs" + ] + }, "UpdateVpcFlowLogsConfig": { "methods": [ "update_vpc_flow_logs_config" @@ -199,6 +313,16 @@ "list_vpc_flow_logs_configs" ] }, + "QueryOrgVpcFlowLogsConfigs": { + "methods": [ + "query_org_vpc_flow_logs_configs" + ] + }, + "ShowEffectiveFlowLogsConfigs": { + "methods": [ + "show_effective_flow_logs_configs" + ] + }, "UpdateVpcFlowLogsConfig": { "methods": [ "update_vpc_flow_logs_config" diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/__init__.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/__init__.py new file mode 100644 index 000000000000..60cbe134687d --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/__init__.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from .async_client import OrganizationVpcFlowLogsServiceAsyncClient +from .client import OrganizationVpcFlowLogsServiceClient + +__all__ = ( + "OrganizationVpcFlowLogsServiceClient", + "OrganizationVpcFlowLogsServiceAsyncClient", +) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/async_client.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/async_client.py new file mode 100644 index 000000000000..a1762149c616 --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/async_client.py @@ -0,0 +1,1702 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +import logging as std_logging +import re +from typing import ( + Callable, + Dict, + Mapping, + MutableMapping, + MutableSequence, + Optional, + Sequence, + Tuple, + Type, + Union, +) + +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1 +from google.api_core import retry_async as retries +from google.api_core.client_options import ClientOptions +from google.auth import credentials as ga_credentials # type: ignore +from google.oauth2 import service_account # type: ignore +import google.protobuf + +from google.cloud.network_management_v1 import gapic_version as package_version + +try: + OptionalRetry = Union[retries.AsyncRetry, gapic_v1.method._MethodDefault, None] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.AsyncRetry, object, None] # type: ignore + +from google.api_core import operation # type: ignore +from google.api_core import operation_async # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf import empty_pb2 # type: ignore +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore + +from google.cloud.network_management_v1.services.organization_vpc_flow_logs_service import ( + pagers, +) +from google.cloud.network_management_v1.types import reachability, vpc_flow_logs +from google.cloud.network_management_v1.types import ( + vpc_flow_logs_config as gcn_vpc_flow_logs_config, +) +from google.cloud.network_management_v1.types import vpc_flow_logs_config + +from .client import OrganizationVpcFlowLogsServiceClient +from .transports.base import ( + DEFAULT_CLIENT_INFO, + OrganizationVpcFlowLogsServiceTransport, +) +from .transports.grpc_asyncio import OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + + +class OrganizationVpcFlowLogsServiceAsyncClient: + """The VPC Flow Logs organization service in the Google Cloud + Network Management API provides organization level + configurations that generate Flow Logs. The service and the + configuration resources created using this service are global. + """ + + _client: OrganizationVpcFlowLogsServiceClient + + # Copy defaults from the synchronous client for use here. + # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead. + DEFAULT_ENDPOINT = OrganizationVpcFlowLogsServiceClient.DEFAULT_ENDPOINT + DEFAULT_MTLS_ENDPOINT = OrganizationVpcFlowLogsServiceClient.DEFAULT_MTLS_ENDPOINT + _DEFAULT_ENDPOINT_TEMPLATE = ( + OrganizationVpcFlowLogsServiceClient._DEFAULT_ENDPOINT_TEMPLATE + ) + _DEFAULT_UNIVERSE = OrganizationVpcFlowLogsServiceClient._DEFAULT_UNIVERSE + + vpc_flow_logs_config_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.vpc_flow_logs_config_path + ) + parse_vpc_flow_logs_config_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.parse_vpc_flow_logs_config_path + ) + common_billing_account_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.common_billing_account_path + ) + parse_common_billing_account_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.parse_common_billing_account_path + ) + common_folder_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.common_folder_path + ) + parse_common_folder_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.parse_common_folder_path + ) + common_organization_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.common_organization_path + ) + parse_common_organization_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.parse_common_organization_path + ) + common_project_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.common_project_path + ) + parse_common_project_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.parse_common_project_path + ) + common_location_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.common_location_path + ) + parse_common_location_path = staticmethod( + OrganizationVpcFlowLogsServiceClient.parse_common_location_path + ) + + @classmethod + def from_service_account_info(cls, info: dict, *args, **kwargs): + """Creates an instance of this client using the provided credentials + info. + + Args: + info (dict): The service account private key info. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + OrganizationVpcFlowLogsServiceAsyncClient: The constructed client. + """ + return OrganizationVpcFlowLogsServiceClient.from_service_account_info.__func__(OrganizationVpcFlowLogsServiceAsyncClient, info, *args, **kwargs) # type: ignore + + @classmethod + def from_service_account_file(cls, filename: str, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + OrganizationVpcFlowLogsServiceAsyncClient: The constructed client. + """ + return OrganizationVpcFlowLogsServiceClient.from_service_account_file.__func__(OrganizationVpcFlowLogsServiceAsyncClient, filename, *args, **kwargs) # type: ignore + + from_service_account_json = from_service_account_file + + @classmethod + def get_mtls_endpoint_and_cert_source( + cls, client_options: Optional[ClientOptions] = None + ): + """Return the API endpoint and client cert source for mutual TLS. + + The client cert source is determined in the following order: + (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the + client cert source is None. + (2) if `client_options.client_cert_source` is provided, use the provided one; if the + default client cert source exists, use the default one; otherwise the client cert + source is None. + + The API endpoint is determined in the following order: + (1) if `client_options.api_endpoint` if provided, use the provided one. + (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the + default mTLS endpoint; if the environment variable is "never", use the default API + endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise + use the default API endpoint. + + More details can be found at https://google.aip.dev/auth/4114. + + Args: + client_options (google.api_core.client_options.ClientOptions): Custom options for the + client. Only the `api_endpoint` and `client_cert_source` properties may be used + in this method. + + Returns: + Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the + client cert source to use. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If any errors happen. + """ + return OrganizationVpcFlowLogsServiceClient.get_mtls_endpoint_and_cert_source(client_options) # type: ignore + + @property + def transport(self) -> OrganizationVpcFlowLogsServiceTransport: + """Returns the transport used by the client instance. + + Returns: + OrganizationVpcFlowLogsServiceTransport: The transport used by the client instance. + """ + return self._client.transport + + @property + def api_endpoint(self): + """Return the API endpoint used by the client instance. + + Returns: + str: The API endpoint used by the client instance. + """ + return self._client._api_endpoint + + @property + def universe_domain(self) -> str: + """Return the universe domain used by the client instance. + + Returns: + str: The universe domain used + by the client instance. + """ + return self._client._universe_domain + + get_transport_class = OrganizationVpcFlowLogsServiceClient.get_transport_class + + def __init__( + self, + *, + credentials: Optional[ga_credentials.Credentials] = None, + transport: Optional[ + Union[ + str, + OrganizationVpcFlowLogsServiceTransport, + Callable[..., OrganizationVpcFlowLogsServiceTransport], + ] + ] = "grpc_asyncio", + client_options: Optional[ClientOptions] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + ) -> None: + """Instantiates the organization vpc flow logs service async client. + + Args: + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + transport (Optional[Union[str,OrganizationVpcFlowLogsServiceTransport,Callable[..., OrganizationVpcFlowLogsServiceTransport]]]): + The transport to use, or a Callable that constructs and returns a new transport to use. + If a Callable is given, it will be called with the same set of initialization + arguments as used in the OrganizationVpcFlowLogsServiceTransport constructor. + If set to None, a transport is chosen automatically. + client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]): + Custom options for the client. + + 1. The ``api_endpoint`` property can be used to override the + default endpoint provided by the client when ``transport`` is + not explicitly provided. Only if this property is not set and + ``transport`` was not explicitly provided, the endpoint is + determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment + variable, which have one of the following values: + "always" (always use the default mTLS endpoint), "never" (always + use the default regular endpoint) and "auto" (auto-switch to the + default mTLS endpoint if client certificate is present; this is + the default value). + + 2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable + is "true", then the ``client_cert_source`` property can be used + to provide a client certificate for mTLS transport. If + not provided, the default SSL client certificate will be used if + present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not + set, no client certificate will be used. + + 3. The ``universe_domain`` property can be used to override the + default "googleapis.com" universe. Note that ``api_endpoint`` + property still takes precedence; and ``universe_domain`` is + currently not supported for mTLS. + + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + + Raises: + google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport + creation failed for any reason. + """ + self._client = OrganizationVpcFlowLogsServiceClient( + credentials=credentials, + transport=transport, + client_options=client_options, + client_info=client_info, + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ): # pragma: NO COVER + _LOGGER.debug( + "Created client `google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient`.", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "universeDomain": getattr( + self._client._transport._credentials, "universe_domain", "" + ), + "credentialsType": f"{type(self._client._transport._credentials).__module__}.{type(self._client._transport._credentials).__qualname__}", + "credentialsInfo": getattr( + self.transport._credentials, "get_cred_info", lambda: None + )(), + } + if hasattr(self._client._transport, "_credentials") + else { + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "credentialsType": None, + }, + ) + + async def list_vpc_flow_logs_configs( + self, + request: Optional[ + Union[vpc_flow_logs.ListVpcFlowLogsConfigsRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListVpcFlowLogsConfigsAsyncPager: + r"""Lists all ``VpcFlowLogsConfigs`` in a given organization. + + .. 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 network_management_v1 + + async def sample_list_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.ListVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_vpc_flow_logs_configs(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest, dict]]): + The request object. Request for the ``ListVpcFlowLogsConfigs`` method. + parent (:class:`str`): + Required. The parent resource of the VpcFlowLogsConfig, + in one of the following formats: + + - For project-level resourcs: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsAsyncPager: + Response for the ListVpcFlowLogsConfigs method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.ListVpcFlowLogsConfigsRequest): + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.list_vpc_flow_logs_configs + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListVpcFlowLogsConfigsAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def get_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.GetVpcFlowLogsConfigRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> vpc_flow_logs_config.VpcFlowLogsConfig: + r"""Gets the details of a specific ``VpcFlowLogsConfig``. + + .. 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 network_management_v1 + + async def sample_get_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.GetVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + response = await client.get_vpc_flow_logs_config(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest, dict]]): + The request object. Request for the ``GetVpcFlowLogsConfig`` method. + name (:class:`str`): + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.types.VpcFlowLogsConfig: + A configuration to generate VPC Flow + Logs. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.GetVpcFlowLogsConfigRequest): + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.get_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def create_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.CreateVpcFlowLogsConfigRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + vpc_flow_logs_config: Optional[ + gcn_vpc_flow_logs_config.VpcFlowLogsConfig + ] = None, + vpc_flow_logs_config_id: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operation_async.AsyncOperation: + r"""Creates a new ``VpcFlowLogsConfig``. If a configuration with the + exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + .. 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 network_management_v1 + + async def sample_create_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.CreateVpcFlowLogsConfigRequest( + parent="parent_value", + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.create_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = (await operation).result() + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest, dict]]): + The request object. Request for the ``CreateVpcFlowLogsConfig`` method. + parent (:class:`str`): + Required. The parent resource of the VpcFlowLogsConfig + to create, in one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + vpc_flow_logs_config (:class:`google.cloud.network_management_v1.types.VpcFlowLogsConfig`): + Required. A ``VpcFlowLogsConfig`` resource + This corresponds to the ``vpc_flow_logs_config`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + vpc_flow_logs_config_id (:class:`str`): + Required. ID of the ``VpcFlowLogsConfig``. + This corresponds to the ``vpc_flow_logs_config_id`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be + :class:`google.cloud.network_management_v1.types.VpcFlowLogsConfig` + A configuration to generate VPC Flow Logs. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent, vpc_flow_logs_config, vpc_flow_logs_config_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.CreateVpcFlowLogsConfigRequest): + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if vpc_flow_logs_config is not None: + request.vpc_flow_logs_config = vpc_flow_logs_config + if vpc_flow_logs_config_id is not None: + request.vpc_flow_logs_config_id = vpc_flow_logs_config_id + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.create_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + gcn_vpc_flow_logs_config.VpcFlowLogsConfig, + metadata_type=reachability.OperationMetadata, + ) + + # Done; return the response. + return response + + async def update_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, dict] + ] = None, + *, + vpc_flow_logs_config: Optional[ + gcn_vpc_flow_logs_config.VpcFlowLogsConfig + ] = None, + update_mask: Optional[field_mask_pb2.FieldMask] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operation_async.AsyncOperation: + r"""Updates an existing ``VpcFlowLogsConfig``. If a configuration + with the exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Updating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + .. 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 network_management_v1 + + async def sample_update_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.UpdateVpcFlowLogsConfigRequest( + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.update_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = (await operation).result() + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.UpdateVpcFlowLogsConfigRequest, dict]]): + The request object. Request for the ``UpdateVpcFlowLogsConfig`` method. + vpc_flow_logs_config (:class:`google.cloud.network_management_v1.types.VpcFlowLogsConfig`): + Required. Only fields specified in update_mask are + updated. + + This corresponds to the ``vpc_flow_logs_config`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Required. Mask of fields to update. At least one path + must be supplied in this field. For example, to change + the state of the configuration to ENABLED, specify + ``update_mask`` = ``"state"``, and the + ``vpc_flow_logs_config`` would be: + ``vpc_flow_logs_config = { name = "projects/my-project/locations/global/vpcFlowLogsConfigs/my-config" state = "ENABLED" }`` + + This corresponds to the ``update_mask`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be + :class:`google.cloud.network_management_v1.types.VpcFlowLogsConfig` + A configuration to generate VPC Flow Logs. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [vpc_flow_logs_config, update_mask] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.UpdateVpcFlowLogsConfigRequest): + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if vpc_flow_logs_config is not None: + request.vpc_flow_logs_config = vpc_flow_logs_config + if update_mask is not None: + request.update_mask = update_mask + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.update_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("vpc_flow_logs_config.name", request.vpc_flow_logs_config.name),) + ), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + gcn_vpc_flow_logs_config.VpcFlowLogsConfig, + metadata_type=reachability.OperationMetadata, + ) + + # Done; return the response. + return response + + async def delete_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operation_async.AsyncOperation: + r"""Deletes a specific ``VpcFlowLogsConfig``. + + .. 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 network_management_v1 + + async def sample_delete_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.DeleteVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = (await operation).result() + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest, dict]]): + The request object. Request for the ``DeleteVpcFlowLogsConfig`` method. + name (:class:`str`): + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For a project-level resource: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For an organization-level resource: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated + empty messages in your APIs. A typical example is to + use it as the request or the response type of an API + method. For instance: + + service Foo { + rpc Bar(google.protobuf.Empty) returns + (google.protobuf.Empty); + + } + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.DeleteVpcFlowLogsConfigRequest): + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.delete_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + empty_pb2.Empty, + metadata_type=reachability.OperationMetadata, + ) + + # Done; return the response. + return response + + async def list_operations( + self, + request: Optional[operations_pb2.ListOperationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.ListOperationsResponse: + r"""Lists operations that match the specified filter in the request. + + Args: + request (:class:`~.operations_pb2.ListOperationsRequest`): + The request object. Request message for + `ListOperations` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.ListOperationsResponse: + Response message for ``ListOperations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.ListOperationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.list_operations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def get_operation( + self, + request: Optional[operations_pb2.GetOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Gets the latest state of a long-running operation. + + Args: + request (:class:`~.operations_pb2.GetOperationRequest`): + The request object. Request message for + `GetOperation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.Operation: + An ``Operation`` object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.GetOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.get_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def delete_operation( + self, + request: Optional[operations_pb2.DeleteOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a long-running operation. + + This method indicates that the client is no longer interested + in the operation result. It does not cancel the operation. + If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.DeleteOperationRequest`): + The request object. Request message for + `DeleteOperation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.DeleteOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.delete_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + async def cancel_operation( + self, + request: Optional[operations_pb2.CancelOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Starts asynchronous cancellation on a long-running operation. + + The server makes a best effort to cancel the operation, but success + is not guaranteed. If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.CancelOperationRequest`): + The request object. Request message for + `CancelOperation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.CancelOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.cancel_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + async def set_iam_policy( + self, + request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Sets the IAM access control policy on the specified function. + + Replaces any existing policy. + + Args: + request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`): + The request object. Request message for `SetIamPolicy` + method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.policy_pb2.Policy: + Defines an Identity and Access Management (IAM) policy. + It is used to specify access control policies for Cloud + Platform resources. + A ``Policy`` is a collection of ``bindings``. A + ``binding`` binds one or more ``members`` to a single + ``role``. Members can be user accounts, service + accounts, Google groups, and domains (such as G Suite). + A ``role`` is a named list of permissions (defined by + IAM or configured by users). A ``binding`` can + optionally specify a ``condition``, which is a logic + expression that further constrains the role binding + based on attributes about the request and/or target + resource. + + **JSON Example** + + :: + + { + "bindings": [ + { + "role": "roles/resourcemanager.organizationAdmin", + "members": [ + "user:mike@example.com", + "group:admins@example.com", + "domain:google.com", + "serviceAccount:my-project-id@appspot.gserviceaccount.com" + ] + }, + { + "role": "roles/resourcemanager.organizationViewer", + "members": ["user:eve@example.com"], + "condition": { + "title": "expirable access", + "description": "Does not grant access after Sep 2020", + "expression": "request.time < + timestamp('2020-10-01T00:00:00.000Z')", + } + } + ] + } + + **YAML Example** + + :: + + bindings: + - members: + - user:mike@example.com + - group:admins@example.com + - domain:google.com + - serviceAccount:my-project-id@appspot.gserviceaccount.com + role: roles/resourcemanager.organizationAdmin + - members: + - user:eve@example.com + role: roles/resourcemanager.organizationViewer + condition: + title: expirable access + description: Does not grant access after Sep 2020 + expression: request.time < timestamp('2020-10-01T00:00:00.000Z') + + For a description of IAM and its features, see the `IAM + developer's + guide `__. + """ + # Create or coerce a protobuf request object. + + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.SetIamPolicyRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.set_iam_policy] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def get_iam_policy( + self, + request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Gets the IAM access control policy for a function. + + Returns an empty policy if the function exists and does not have a + policy set. + + Args: + request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`): + The request object. Request message for `GetIamPolicy` + method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if + any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.policy_pb2.Policy: + Defines an Identity and Access Management (IAM) policy. + It is used to specify access control policies for Cloud + Platform resources. + A ``Policy`` is a collection of ``bindings``. A + ``binding`` binds one or more ``members`` to a single + ``role``. Members can be user accounts, service + accounts, Google groups, and domains (such as G Suite). + A ``role`` is a named list of permissions (defined by + IAM or configured by users). A ``binding`` can + optionally specify a ``condition``, which is a logic + expression that further constrains the role binding + based on attributes about the request and/or target + resource. + + **JSON Example** + + :: + + { + "bindings": [ + { + "role": "roles/resourcemanager.organizationAdmin", + "members": [ + "user:mike@example.com", + "group:admins@example.com", + "domain:google.com", + "serviceAccount:my-project-id@appspot.gserviceaccount.com" + ] + }, + { + "role": "roles/resourcemanager.organizationViewer", + "members": ["user:eve@example.com"], + "condition": { + "title": "expirable access", + "description": "Does not grant access after Sep 2020", + "expression": "request.time < + timestamp('2020-10-01T00:00:00.000Z')", + } + } + ] + } + + **YAML Example** + + :: + + bindings: + - members: + - user:mike@example.com + - group:admins@example.com + - domain:google.com + - serviceAccount:my-project-id@appspot.gserviceaccount.com + role: roles/resourcemanager.organizationAdmin + - members: + - user:eve@example.com + role: roles/resourcemanager.organizationViewer + condition: + title: expirable access + description: Does not grant access after Sep 2020 + expression: request.time < timestamp('2020-10-01T00:00:00.000Z') + + For a description of IAM and its features, see the `IAM + developer's + guide `__. + """ + # Create or coerce a protobuf request object. + + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.GetIamPolicyRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.get_iam_policy] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def test_iam_permissions( + self, + request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> iam_policy_pb2.TestIamPermissionsResponse: + r"""Tests the specified IAM permissions against the IAM access control + policy for a function. + + If the function does not exist, this will return an empty set + of permissions, not a NOT_FOUND error. + + Args: + request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`): + The request object. Request message for + `TestIamPermissions` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.iam_policy_pb2.TestIamPermissionsResponse: + Response message for ``TestIamPermissions`` method. + """ + # Create or coerce a protobuf request object. + + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.TestIamPermissionsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[ + self._client._transport.test_iam_permissions + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def get_location( + self, + request: Optional[locations_pb2.GetLocationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.Location: + r"""Gets information about a location. + + Args: + request (:class:`~.location_pb2.GetLocationRequest`): + The request object. Request message for + `GetLocation` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.Location: + Location object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.GetLocationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.get_location] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_locations( + self, + request: Optional[locations_pb2.ListLocationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.ListLocationsResponse: + r"""Lists information about the supported locations for this service. + + Args: + request (:class:`~.location_pb2.ListLocationsRequest`): + The request object. Request message for + `ListLocations` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.ListLocationsResponse: + Response message for ``ListLocations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.ListLocationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self.transport._wrapped_methods[self._client._transport.list_locations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def __aenter__(self) -> "OrganizationVpcFlowLogsServiceAsyncClient": + return self + + async def __aexit__(self, exc_type, exc, tb): + await self.transport.close() + + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=package_version.__version__ +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + + +__all__ = ("OrganizationVpcFlowLogsServiceAsyncClient",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/client.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/client.py new file mode 100644 index 000000000000..12de466c09c0 --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/client.py @@ -0,0 +1,2153 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +from http import HTTPStatus +import json +import logging as std_logging +import os +import re +from typing import ( + Callable, + Dict, + Mapping, + MutableMapping, + MutableSequence, + Optional, + Sequence, + Tuple, + Type, + Union, + cast, +) +import warnings + +from google.api_core import client_options as client_options_lib +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1 +from google.api_core import retry as retries +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.exceptions import MutualTLSChannelError # type: ignore +from google.auth.transport import mtls # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.oauth2 import service_account # type: ignore +import google.protobuf + +from google.cloud.network_management_v1 import gapic_version as package_version + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object, None] # type: ignore + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + +from google.api_core import operation # type: ignore +from google.api_core import operation_async # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf import empty_pb2 # type: ignore +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore + +from google.cloud.network_management_v1.services.organization_vpc_flow_logs_service import ( + pagers, +) +from google.cloud.network_management_v1.types import reachability, vpc_flow_logs +from google.cloud.network_management_v1.types import ( + vpc_flow_logs_config as gcn_vpc_flow_logs_config, +) +from google.cloud.network_management_v1.types import vpc_flow_logs_config + +from .transports.base import ( + DEFAULT_CLIENT_INFO, + OrganizationVpcFlowLogsServiceTransport, +) +from .transports.grpc import OrganizationVpcFlowLogsServiceGrpcTransport +from .transports.grpc_asyncio import OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport +from .transports.rest import OrganizationVpcFlowLogsServiceRestTransport + + +class OrganizationVpcFlowLogsServiceClientMeta(type): + """Metaclass for the OrganizationVpcFlowLogsService client. + + This provides class-level methods for building and retrieving + support objects (e.g. transport) without polluting the client instance + objects. + """ + + _transport_registry = ( + OrderedDict() + ) # type: Dict[str, Type[OrganizationVpcFlowLogsServiceTransport]] + _transport_registry["grpc"] = OrganizationVpcFlowLogsServiceGrpcTransport + _transport_registry[ + "grpc_asyncio" + ] = OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport + _transport_registry["rest"] = OrganizationVpcFlowLogsServiceRestTransport + + def get_transport_class( + cls, + label: Optional[str] = None, + ) -> Type[OrganizationVpcFlowLogsServiceTransport]: + """Returns an appropriate transport class. + + Args: + label: The name of the desired transport. If none is + provided, then the first transport in the registry is used. + + Returns: + The transport class to use. + """ + # If a specific transport is requested, return that one. + if label: + return cls._transport_registry[label] + + # No transport is requested; return the default (that is, the first one + # in the dictionary). + return next(iter(cls._transport_registry.values())) + + +class OrganizationVpcFlowLogsServiceClient( + metaclass=OrganizationVpcFlowLogsServiceClientMeta +): + """The VPC Flow Logs organization service in the Google Cloud + Network Management API provides organization level + configurations that generate Flow Logs. The service and the + configuration resources created using this service are global. + """ + + @staticmethod + def _get_default_mtls_endpoint(api_endpoint): + """Converts api endpoint to mTLS endpoint. + + Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to + "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively. + Args: + api_endpoint (Optional[str]): the api endpoint to convert. + Returns: + str: converted mTLS api endpoint. + """ + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead. + DEFAULT_ENDPOINT = "networkmanagement.googleapis.com" + DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore + DEFAULT_ENDPOINT + ) + + _DEFAULT_ENDPOINT_TEMPLATE = "networkmanagement.{UNIVERSE_DOMAIN}" + _DEFAULT_UNIVERSE = "googleapis.com" + + @classmethod + def from_service_account_info(cls, info: dict, *args, **kwargs): + """Creates an instance of this client using the provided credentials + info. + + Args: + info (dict): The service account private key info. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + OrganizationVpcFlowLogsServiceClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_info(info) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + @classmethod + def from_service_account_file(cls, filename: str, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + OrganizationVpcFlowLogsServiceClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_file(filename) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + from_service_account_json = from_service_account_file + + @property + def transport(self) -> OrganizationVpcFlowLogsServiceTransport: + """Returns the transport used by the client instance. + + Returns: + OrganizationVpcFlowLogsServiceTransport: The transport used by the client + instance. + """ + return self._transport + + @staticmethod + def vpc_flow_logs_config_path( + project: str, + location: str, + vpc_flow_logs_config: str, + ) -> str: + """Returns a fully-qualified vpc_flow_logs_config string.""" + return "projects/{project}/locations/{location}/vpcFlowLogsConfigs/{vpc_flow_logs_config}".format( + project=project, + location=location, + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + @staticmethod + def parse_vpc_flow_logs_config_path(path: str) -> Dict[str, str]: + """Parses a vpc_flow_logs_config path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/vpcFlowLogsConfigs/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + + @staticmethod + def common_billing_account_path( + billing_account: str, + ) -> str: + """Returns a fully-qualified billing_account string.""" + return "billingAccounts/{billing_account}".format( + billing_account=billing_account, + ) + + @staticmethod + def parse_common_billing_account_path(path: str) -> Dict[str, str]: + """Parse a billing_account path into its component segments.""" + m = re.match(r"^billingAccounts/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_folder_path( + folder: str, + ) -> str: + """Returns a fully-qualified folder string.""" + return "folders/{folder}".format( + folder=folder, + ) + + @staticmethod + def parse_common_folder_path(path: str) -> Dict[str, str]: + """Parse a folder path into its component segments.""" + m = re.match(r"^folders/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_organization_path( + organization: str, + ) -> str: + """Returns a fully-qualified organization string.""" + return "organizations/{organization}".format( + organization=organization, + ) + + @staticmethod + def parse_common_organization_path(path: str) -> Dict[str, str]: + """Parse a organization path into its component segments.""" + m = re.match(r"^organizations/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_project_path( + project: str, + ) -> str: + """Returns a fully-qualified project string.""" + return "projects/{project}".format( + project=project, + ) + + @staticmethod + def parse_common_project_path(path: str) -> Dict[str, str]: + """Parse a project path into its component segments.""" + m = re.match(r"^projects/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_location_path( + project: str, + location: str, + ) -> str: + """Returns a fully-qualified location string.""" + return "projects/{project}/locations/{location}".format( + project=project, + location=location, + ) + + @staticmethod + def parse_common_location_path(path: str) -> Dict[str, str]: + """Parse a location path into its component segments.""" + m = re.match(r"^projects/(?P.+?)/locations/(?P.+?)$", path) + return m.groupdict() if m else {} + + @classmethod + def get_mtls_endpoint_and_cert_source( + cls, client_options: Optional[client_options_lib.ClientOptions] = None + ): + """Deprecated. Return the API endpoint and client cert source for mutual TLS. + + The client cert source is determined in the following order: + (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the + client cert source is None. + (2) if `client_options.client_cert_source` is provided, use the provided one; if the + default client cert source exists, use the default one; otherwise the client cert + source is None. + + The API endpoint is determined in the following order: + (1) if `client_options.api_endpoint` if provided, use the provided one. + (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the + default mTLS endpoint; if the environment variable is "never", use the default API + endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise + use the default API endpoint. + + More details can be found at https://google.aip.dev/auth/4114. + + Args: + client_options (google.api_core.client_options.ClientOptions): Custom options for the + client. Only the `api_endpoint` and `client_cert_source` properties may be used + in this method. + + Returns: + Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the + client cert source to use. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If any errors happen. + """ + + warnings.warn( + "get_mtls_endpoint_and_cert_source is deprecated. Use the api_endpoint property instead.", + DeprecationWarning, + ) + if client_options is None: + client_options = client_options_lib.ClientOptions() + use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false") + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto") + if use_client_cert not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + # Figure out the client cert source to use. + client_cert_source = None + if use_client_cert == "true": + if client_options.client_cert_source: + client_cert_source = client_options.client_cert_source + elif mtls.has_default_client_cert_source(): + client_cert_source = mtls.default_client_cert_source() + + # Figure out which api endpoint to use. + if client_options.api_endpoint is not None: + api_endpoint = client_options.api_endpoint + elif use_mtls_endpoint == "always" or ( + use_mtls_endpoint == "auto" and client_cert_source + ): + api_endpoint = cls.DEFAULT_MTLS_ENDPOINT + else: + api_endpoint = cls.DEFAULT_ENDPOINT + + return api_endpoint, client_cert_source + + @staticmethod + def _read_environment_variables(): + """Returns the environment variables used by the client. + + Returns: + Tuple[bool, str, str]: returns the GOOGLE_API_USE_CLIENT_CERTIFICATE, + GOOGLE_API_USE_MTLS_ENDPOINT, and GOOGLE_CLOUD_UNIVERSE_DOMAIN environment variables. + + Raises: + ValueError: If GOOGLE_API_USE_CLIENT_CERTIFICATE is not + any of ["true", "false"]. + google.auth.exceptions.MutualTLSChannelError: If GOOGLE_API_USE_MTLS_ENDPOINT + is not any of ["auto", "never", "always"]. + """ + use_client_cert = os.getenv( + "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false" + ).lower() + use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower() + universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN") + if use_client_cert not in ("true", "false"): + raise ValueError( + "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + if use_mtls_endpoint not in ("auto", "never", "always"): + raise MutualTLSChannelError( + "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + return use_client_cert == "true", use_mtls_endpoint, universe_domain_env + + @staticmethod + def _get_client_cert_source(provided_cert_source, use_cert_flag): + """Return the client cert source to be used by the client. + + Args: + provided_cert_source (bytes): The client certificate source provided. + use_cert_flag (bool): A flag indicating whether to use the client certificate. + + Returns: + bytes or None: The client cert source to be used by the client. + """ + client_cert_source = None + if use_cert_flag: + if provided_cert_source: + client_cert_source = provided_cert_source + elif mtls.has_default_client_cert_source(): + client_cert_source = mtls.default_client_cert_source() + return client_cert_source + + @staticmethod + def _get_api_endpoint( + api_override, client_cert_source, universe_domain, use_mtls_endpoint + ): + """Return the API endpoint used by the client. + + Args: + api_override (str): The API endpoint override. If specified, this is always + the return value of this function and the other arguments are not used. + client_cert_source (bytes): The client certificate source used by the client. + universe_domain (str): The universe domain used by the client. + use_mtls_endpoint (str): How to use the mTLS endpoint, which depends also on the other parameters. + Possible values are "always", "auto", or "never". + + Returns: + str: The API endpoint to be used by the client. + """ + if api_override is not None: + api_endpoint = api_override + elif use_mtls_endpoint == "always" or ( + use_mtls_endpoint == "auto" and client_cert_source + ): + _default_universe = OrganizationVpcFlowLogsServiceClient._DEFAULT_UNIVERSE + if universe_domain != _default_universe: + raise MutualTLSChannelError( + f"mTLS is not supported in any universe other than {_default_universe}." + ) + api_endpoint = OrganizationVpcFlowLogsServiceClient.DEFAULT_MTLS_ENDPOINT + else: + api_endpoint = ( + OrganizationVpcFlowLogsServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=universe_domain + ) + ) + return api_endpoint + + @staticmethod + def _get_universe_domain( + client_universe_domain: Optional[str], universe_domain_env: Optional[str] + ) -> str: + """Return the universe domain used by the client. + + Args: + client_universe_domain (Optional[str]): The universe domain configured via the client options. + universe_domain_env (Optional[str]): The universe domain configured via the "GOOGLE_CLOUD_UNIVERSE_DOMAIN" environment variable. + + Returns: + str: The universe domain to be used by the client. + + Raises: + ValueError: If the universe domain is an empty string. + """ + universe_domain = OrganizationVpcFlowLogsServiceClient._DEFAULT_UNIVERSE + if client_universe_domain is not None: + universe_domain = client_universe_domain + elif universe_domain_env is not None: + universe_domain = universe_domain_env + if len(universe_domain.strip()) == 0: + raise ValueError("Universe Domain cannot be an empty string.") + return universe_domain + + def _validate_universe_domain(self): + """Validates client's and credentials' universe domains are consistent. + + Returns: + bool: True iff the configured universe domain is valid. + + Raises: + ValueError: If the configured universe domain is not valid. + """ + + # NOTE (b/349488459): universe validation is disabled until further notice. + return True + + def _add_cred_info_for_auth_errors( + self, error: core_exceptions.GoogleAPICallError + ) -> None: + """Adds credential info string to error details for 401/403/404 errors. + + Args: + error (google.api_core.exceptions.GoogleAPICallError): The error to add the cred info. + """ + if error.code not in [ + HTTPStatus.UNAUTHORIZED, + HTTPStatus.FORBIDDEN, + HTTPStatus.NOT_FOUND, + ]: + return + + cred = self._transport._credentials + + # get_cred_info is only available in google-auth>=2.35.0 + if not hasattr(cred, "get_cred_info"): + return + + # ignore the type check since pypy test fails when get_cred_info + # is not available + cred_info = cred.get_cred_info() # type: ignore + if cred_info and hasattr(error._details, "append"): + error._details.append(json.dumps(cred_info)) + + @property + def api_endpoint(self): + """Return the API endpoint used by the client instance. + + Returns: + str: The API endpoint used by the client instance. + """ + return self._api_endpoint + + @property + def universe_domain(self) -> str: + """Return the universe domain used by the client instance. + + Returns: + str: The universe domain used by the client instance. + """ + return self._universe_domain + + def __init__( + self, + *, + credentials: Optional[ga_credentials.Credentials] = None, + transport: Optional[ + Union[ + str, + OrganizationVpcFlowLogsServiceTransport, + Callable[..., OrganizationVpcFlowLogsServiceTransport], + ] + ] = None, + client_options: Optional[Union[client_options_lib.ClientOptions, dict]] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + ) -> None: + """Instantiates the organization vpc flow logs service client. + + Args: + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + transport (Optional[Union[str,OrganizationVpcFlowLogsServiceTransport,Callable[..., OrganizationVpcFlowLogsServiceTransport]]]): + The transport to use, or a Callable that constructs and returns a new transport. + If a Callable is given, it will be called with the same set of initialization + arguments as used in the OrganizationVpcFlowLogsServiceTransport constructor. + If set to None, a transport is chosen automatically. + client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]): + Custom options for the client. + + 1. The ``api_endpoint`` property can be used to override the + default endpoint provided by the client when ``transport`` is + not explicitly provided. Only if this property is not set and + ``transport`` was not explicitly provided, the endpoint is + determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment + variable, which have one of the following values: + "always" (always use the default mTLS endpoint), "never" (always + use the default regular endpoint) and "auto" (auto-switch to the + default mTLS endpoint if client certificate is present; this is + the default value). + + 2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable + is "true", then the ``client_cert_source`` property can be used + to provide a client certificate for mTLS transport. If + not provided, the default SSL client certificate will be used if + present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not + set, no client certificate will be used. + + 3. The ``universe_domain`` property can be used to override the + default "googleapis.com" universe. Note that the ``api_endpoint`` + property still takes precedence; and ``universe_domain`` is + currently not supported for mTLS. + + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport + creation failed for any reason. + """ + self._client_options = client_options + if isinstance(self._client_options, dict): + self._client_options = client_options_lib.from_dict(self._client_options) + if self._client_options is None: + self._client_options = client_options_lib.ClientOptions() + self._client_options = cast( + client_options_lib.ClientOptions, self._client_options + ) + + universe_domain_opt = getattr(self._client_options, "universe_domain", None) + + ( + self._use_client_cert, + self._use_mtls_endpoint, + self._universe_domain_env, + ) = OrganizationVpcFlowLogsServiceClient._read_environment_variables() + self._client_cert_source = ( + OrganizationVpcFlowLogsServiceClient._get_client_cert_source( + self._client_options.client_cert_source, self._use_client_cert + ) + ) + self._universe_domain = ( + OrganizationVpcFlowLogsServiceClient._get_universe_domain( + universe_domain_opt, self._universe_domain_env + ) + ) + self._api_endpoint = None # updated below, depending on `transport` + + # Initialize the universe domain validation. + self._is_universe_domain_valid = False + + if CLIENT_LOGGING_SUPPORTED: # pragma: NO COVER + # Setup logging. + client_logging.initialize_logging() + + api_key_value = getattr(self._client_options, "api_key", None) + if api_key_value and credentials: + raise ValueError( + "client_options.api_key and credentials are mutually exclusive" + ) + + # Save or instantiate the transport. + # Ordinarily, we provide the transport, but allowing a custom transport + # instance provides an extensibility point for unusual situations. + transport_provided = isinstance( + transport, OrganizationVpcFlowLogsServiceTransport + ) + if transport_provided: + # transport is a OrganizationVpcFlowLogsServiceTransport instance. + if credentials or self._client_options.credentials_file or api_key_value: + raise ValueError( + "When providing a transport instance, " + "provide its credentials directly." + ) + if self._client_options.scopes: + raise ValueError( + "When providing a transport instance, provide its scopes " + "directly." + ) + self._transport = cast(OrganizationVpcFlowLogsServiceTransport, transport) + self._api_endpoint = self._transport.host + + self._api_endpoint = ( + self._api_endpoint + or OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + self._client_options.api_endpoint, + self._client_cert_source, + self._universe_domain, + self._use_mtls_endpoint, + ) + ) + + if not transport_provided: + import google.auth._default # type: ignore + + if api_key_value and hasattr( + google.auth._default, "get_api_key_credentials" + ): + credentials = google.auth._default.get_api_key_credentials( + api_key_value + ) + + transport_init: Union[ + Type[OrganizationVpcFlowLogsServiceTransport], + Callable[..., OrganizationVpcFlowLogsServiceTransport], + ] = ( + OrganizationVpcFlowLogsServiceClient.get_transport_class(transport) + if isinstance(transport, str) or transport is None + else cast( + Callable[..., OrganizationVpcFlowLogsServiceTransport], transport + ) + ) + # initialize with the provided callable or the passed in class + self._transport = transport_init( + credentials=credentials, + credentials_file=self._client_options.credentials_file, + host=self._api_endpoint, + scopes=self._client_options.scopes, + client_cert_source_for_mtls=self._client_cert_source, + quota_project_id=self._client_options.quota_project_id, + client_info=client_info, + always_use_jwt_access=True, + api_audience=self._client_options.api_audience, + ) + + if "async" not in str(self._transport): + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ): # pragma: NO COVER + _LOGGER.debug( + "Created client `google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient`.", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "universeDomain": getattr( + self._transport._credentials, "universe_domain", "" + ), + "credentialsType": f"{type(self._transport._credentials).__module__}.{type(self._transport._credentials).__qualname__}", + "credentialsInfo": getattr( + self.transport._credentials, "get_cred_info", lambda: None + )(), + } + if hasattr(self._transport, "_credentials") + else { + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "credentialsType": None, + }, + ) + + def list_vpc_flow_logs_configs( + self, + request: Optional[ + Union[vpc_flow_logs.ListVpcFlowLogsConfigsRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ListVpcFlowLogsConfigsPager: + r"""Lists all ``VpcFlowLogsConfigs`` in a given organization. + + .. 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 network_management_v1 + + def sample_list_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.ListVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_vpc_flow_logs_configs(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest, dict]): + The request object. Request for the ``ListVpcFlowLogsConfigs`` method. + parent (str): + Required. The parent resource of the VpcFlowLogsConfig, + in one of the following formats: + + - For project-level resourcs: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsPager: + Response for the ListVpcFlowLogsConfigs method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.ListVpcFlowLogsConfigsRequest): + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.list_vpc_flow_logs_configs + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListVpcFlowLogsConfigsPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def get_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.GetVpcFlowLogsConfigRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> vpc_flow_logs_config.VpcFlowLogsConfig: + r"""Gets the details of a specific ``VpcFlowLogsConfig``. + + .. 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 network_management_v1 + + def sample_get_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.GetVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + response = client.get_vpc_flow_logs_config(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest, dict]): + The request object. Request for the ``GetVpcFlowLogsConfig`` method. + name (str): + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.types.VpcFlowLogsConfig: + A configuration to generate VPC Flow + Logs. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.GetVpcFlowLogsConfigRequest): + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_vpc_flow_logs_config] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def create_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.CreateVpcFlowLogsConfigRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + vpc_flow_logs_config: Optional[ + gcn_vpc_flow_logs_config.VpcFlowLogsConfig + ] = None, + vpc_flow_logs_config_id: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operation.Operation: + r"""Creates a new ``VpcFlowLogsConfig``. If a configuration with the + exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + .. 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 network_management_v1 + + def sample_create_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.CreateVpcFlowLogsConfigRequest( + parent="parent_value", + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.create_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest, dict]): + The request object. Request for the ``CreateVpcFlowLogsConfig`` method. + parent (str): + Required. The parent resource of the VpcFlowLogsConfig + to create, in one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + vpc_flow_logs_config (google.cloud.network_management_v1.types.VpcFlowLogsConfig): + Required. A ``VpcFlowLogsConfig`` resource + This corresponds to the ``vpc_flow_logs_config`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + vpc_flow_logs_config_id (str): + Required. ID of the ``VpcFlowLogsConfig``. + This corresponds to the ``vpc_flow_logs_config_id`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be + :class:`google.cloud.network_management_v1.types.VpcFlowLogsConfig` + A configuration to generate VPC Flow Logs. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [parent, vpc_flow_logs_config, vpc_flow_logs_config_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.CreateVpcFlowLogsConfigRequest): + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if vpc_flow_logs_config is not None: + request.vpc_flow_logs_config = vpc_flow_logs_config + if vpc_flow_logs_config_id is not None: + request.vpc_flow_logs_config_id = vpc_flow_logs_config_id + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.create_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + gcn_vpc_flow_logs_config.VpcFlowLogsConfig, + metadata_type=reachability.OperationMetadata, + ) + + # Done; return the response. + return response + + def update_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, dict] + ] = None, + *, + vpc_flow_logs_config: Optional[ + gcn_vpc_flow_logs_config.VpcFlowLogsConfig + ] = None, + update_mask: Optional[field_mask_pb2.FieldMask] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operation.Operation: + r"""Updates an existing ``VpcFlowLogsConfig``. If a configuration + with the exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Updating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + .. 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 network_management_v1 + + def sample_update_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.UpdateVpcFlowLogsConfigRequest( + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.update_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.UpdateVpcFlowLogsConfigRequest, dict]): + The request object. Request for the ``UpdateVpcFlowLogsConfig`` method. + vpc_flow_logs_config (google.cloud.network_management_v1.types.VpcFlowLogsConfig): + Required. Only fields specified in update_mask are + updated. + + This corresponds to the ``vpc_flow_logs_config`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. Mask of fields to update. At least one path + must be supplied in this field. For example, to change + the state of the configuration to ENABLED, specify + ``update_mask`` = ``"state"``, and the + ``vpc_flow_logs_config`` would be: + ``vpc_flow_logs_config = { name = "projects/my-project/locations/global/vpcFlowLogsConfigs/my-config" state = "ENABLED" }`` + + This corresponds to the ``update_mask`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be + :class:`google.cloud.network_management_v1.types.VpcFlowLogsConfig` + A configuration to generate VPC Flow Logs. + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [vpc_flow_logs_config, update_mask] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.UpdateVpcFlowLogsConfigRequest): + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if vpc_flow_logs_config is not None: + request.vpc_flow_logs_config = vpc_flow_logs_config + if update_mask is not None: + request.update_mask = update_mask + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.update_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("vpc_flow_logs_config.name", request.vpc_flow_logs_config.name),) + ), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + gcn_vpc_flow_logs_config.VpcFlowLogsConfig, + metadata_type=reachability.OperationMetadata, + ) + + # Done; return the response. + return response + + def delete_vpc_flow_logs_config( + self, + request: Optional[ + Union[vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operation.Operation: + r"""Deletes a specific ``VpcFlowLogsConfig``. + + .. 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 network_management_v1 + + def sample_delete_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.DeleteVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest, dict]): + The request object. Request for the ``DeleteVpcFlowLogsConfig`` method. + name (str): + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For a project-level resource: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For an organization-level resource: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated + empty messages in your APIs. A typical example is to + use it as the request or the response type of an API + method. For instance: + + service Foo { + rpc Bar(google.protobuf.Empty) returns + (google.protobuf.Empty); + + } + + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.DeleteVpcFlowLogsConfigRequest): + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.delete_vpc_flow_logs_config + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + empty_pb2.Empty, + metadata_type=reachability.OperationMetadata, + ) + + # Done; return the response. + return response + + def __enter__(self) -> "OrganizationVpcFlowLogsServiceClient": + return self + + def __exit__(self, type, value, traceback): + """Releases underlying transport's resources. + + .. warning:: + ONLY use as a context manager if the transport is NOT shared + with other clients! Exiting the with block will CLOSE the transport + and may cause errors in other clients! + """ + self.transport.close() + + def list_operations( + self, + request: Optional[operations_pb2.ListOperationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.ListOperationsResponse: + r"""Lists operations that match the specified filter in the request. + + Args: + request (:class:`~.operations_pb2.ListOperationsRequest`): + The request object. Request message for + `ListOperations` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.ListOperationsResponse: + Response message for ``ListOperations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.ListOperationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_operations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def get_operation( + self, + request: Optional[operations_pb2.GetOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Gets the latest state of a long-running operation. + + Args: + request (:class:`~.operations_pb2.GetOperationRequest`): + The request object. Request message for + `GetOperation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.operations_pb2.Operation: + An ``Operation`` object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.GetOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def delete_operation( + self, + request: Optional[operations_pb2.DeleteOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a long-running operation. + + This method indicates that the client is no longer interested + in the operation result. It does not cancel the operation. + If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.DeleteOperationRequest`): + The request object. Request message for + `DeleteOperation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.DeleteOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.delete_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + def cancel_operation( + self, + request: Optional[operations_pb2.CancelOperationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Starts asynchronous cancellation on a long-running operation. + + The server makes a best effort to cancel the operation, but success + is not guaranteed. If the server doesn't support this method, it returns + `google.rpc.Code.UNIMPLEMENTED`. + + Args: + request (:class:`~.operations_pb2.CancelOperationRequest`): + The request object. Request message for + `CancelOperation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + None + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = operations_pb2.CancelOperationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.cancel_operation] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + def set_iam_policy( + self, + request: Optional[iam_policy_pb2.SetIamPolicyRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Sets the IAM access control policy on the specified function. + + Replaces any existing policy. + + Args: + request (:class:`~.iam_policy_pb2.SetIamPolicyRequest`): + The request object. Request message for `SetIamPolicy` + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.policy_pb2.Policy: + Defines an Identity and Access Management (IAM) policy. + It is used to specify access control policies for Cloud + Platform resources. + A ``Policy`` is a collection of ``bindings``. A + ``binding`` binds one or more ``members`` to a single + ``role``. Members can be user accounts, service + accounts, Google groups, and domains (such as G Suite). + A ``role`` is a named list of permissions (defined by + IAM or configured by users). A ``binding`` can + optionally specify a ``condition``, which is a logic + expression that further constrains the role binding + based on attributes about the request and/or target + resource. + + **JSON Example** + + :: + + { + "bindings": [ + { + "role": "roles/resourcemanager.organizationAdmin", + "members": [ + "user:mike@example.com", + "group:admins@example.com", + "domain:google.com", + "serviceAccount:my-project-id@appspot.gserviceaccount.com" + ] + }, + { + "role": "roles/resourcemanager.organizationViewer", + "members": ["user:eve@example.com"], + "condition": { + "title": "expirable access", + "description": "Does not grant access after Sep 2020", + "expression": "request.time < + timestamp('2020-10-01T00:00:00.000Z')", + } + } + ] + } + + **YAML Example** + + :: + + bindings: + - members: + - user:mike@example.com + - group:admins@example.com + - domain:google.com + - serviceAccount:my-project-id@appspot.gserviceaccount.com + role: roles/resourcemanager.organizationAdmin + - members: + - user:eve@example.com + role: roles/resourcemanager.organizationViewer + condition: + title: expirable access + description: Does not grant access after Sep 2020 + expression: request.time < timestamp('2020-10-01T00:00:00.000Z') + + For a description of IAM and its features, see the `IAM + developer's + guide `__. + """ + # Create or coerce a protobuf request object. + + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.SetIamPolicyRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.set_iam_policy] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def get_iam_policy( + self, + request: Optional[iam_policy_pb2.GetIamPolicyRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Gets the IAM access control policy for a function. + + Returns an empty policy if the function exists and does not have a + policy set. + + Args: + request (:class:`~.iam_policy_pb2.GetIamPolicyRequest`): + The request object. Request message for `GetIamPolicy` + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.policy_pb2.Policy: + Defines an Identity and Access Management (IAM) policy. + It is used to specify access control policies for Cloud + Platform resources. + A ``Policy`` is a collection of ``bindings``. A + ``binding`` binds one or more ``members`` to a single + ``role``. Members can be user accounts, service + accounts, Google groups, and domains (such as G Suite). + A ``role`` is a named list of permissions (defined by + IAM or configured by users). A ``binding`` can + optionally specify a ``condition``, which is a logic + expression that further constrains the role binding + based on attributes about the request and/or target + resource. + + **JSON Example** + + :: + + { + "bindings": [ + { + "role": "roles/resourcemanager.organizationAdmin", + "members": [ + "user:mike@example.com", + "group:admins@example.com", + "domain:google.com", + "serviceAccount:my-project-id@appspot.gserviceaccount.com" + ] + }, + { + "role": "roles/resourcemanager.organizationViewer", + "members": ["user:eve@example.com"], + "condition": { + "title": "expirable access", + "description": "Does not grant access after Sep 2020", + "expression": "request.time < + timestamp('2020-10-01T00:00:00.000Z')", + } + } + ] + } + + **YAML Example** + + :: + + bindings: + - members: + - user:mike@example.com + - group:admins@example.com + - domain:google.com + - serviceAccount:my-project-id@appspot.gserviceaccount.com + role: roles/resourcemanager.organizationAdmin + - members: + - user:eve@example.com + role: roles/resourcemanager.organizationViewer + condition: + title: expirable access + description: Does not grant access after Sep 2020 + expression: request.time < timestamp('2020-10-01T00:00:00.000Z') + + For a description of IAM and its features, see the `IAM + developer's + guide `__. + """ + # Create or coerce a protobuf request object. + + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.GetIamPolicyRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_iam_policy] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def test_iam_permissions( + self, + request: Optional[iam_policy_pb2.TestIamPermissionsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> iam_policy_pb2.TestIamPermissionsResponse: + r"""Tests the specified IAM permissions against the IAM access control + policy for a function. + + If the function does not exist, this will return an empty set + of permissions, not a NOT_FOUND error. + + Args: + request (:class:`~.iam_policy_pb2.TestIamPermissionsRequest`): + The request object. Request message for + `TestIamPermissions` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.iam_policy_pb2.TestIamPermissionsResponse: + Response message for ``TestIamPermissions`` method. + """ + # Create or coerce a protobuf request object. + + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.TestIamPermissionsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.test_iam_permissions] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def get_location( + self, + request: Optional[locations_pb2.GetLocationRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.Location: + r"""Gets information about a location. + + Args: + request (:class:`~.location_pb2.GetLocationRequest`): + The request object. Request message for + `GetLocation` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.Location: + Location object. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.GetLocationRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_location] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + def list_locations( + self, + request: Optional[locations_pb2.ListLocationsRequest] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.ListLocationsResponse: + r"""Lists information about the supported locations for this service. + + Args: + request (:class:`~.location_pb2.ListLocationsRequest`): + The request object. Request message for + `ListLocations` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + Returns: + ~.location_pb2.ListLocationsResponse: + Response message for ``ListLocations`` method. + """ + # Create or coerce a protobuf request object. + # The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = locations_pb2.ListLocationsRequest(**request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_locations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + try: + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + except core_exceptions.GoogleAPICallError as e: + self._add_cred_info_for_auth_errors(e) + raise e + + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=package_version.__version__ +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + +__all__ = ("OrganizationVpcFlowLogsServiceClient",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/pagers.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/pagers.py new file mode 100644 index 000000000000..6502a505d0ce --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/pagers.py @@ -0,0 +1,199 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from typing import ( + Any, + AsyncIterator, + Awaitable, + Callable, + Iterator, + Optional, + Sequence, + Tuple, + Union, +) + +from google.api_core import gapic_v1 +from google.api_core import retry as retries +from google.api_core import retry_async as retries_async + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] + OptionalAsyncRetry = Union[ + retries_async.AsyncRetry, gapic_v1.method._MethodDefault, None + ] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object, None] # type: ignore + OptionalAsyncRetry = Union[retries_async.AsyncRetry, object, None] # type: ignore + +from google.cloud.network_management_v1.types import vpc_flow_logs, vpc_flow_logs_config + + +class ListVpcFlowLogsConfigsPager: + """A pager for iterating through ``list_vpc_flow_logs_configs`` requests. + + This class thinly wraps an initial + :class:`google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``vpc_flow_logs_configs`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListVpcFlowLogsConfigs`` requests and continue to iterate + through the ``vpc_flow_logs_configs`` field on the + corresponding responses. + + All the usual :class:`google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsResponse` + 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[..., vpc_flow_logs.ListVpcFlowLogsConfigsResponse], + request: vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + response: vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest): + The initial request object. + response (google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[vpc_flow_logs.ListVpcFlowLogsConfigsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[vpc_flow_logs_config.VpcFlowLogsConfig]: + for page in self.pages: + yield from page.vpc_flow_logs_configs + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListVpcFlowLogsConfigsAsyncPager: + """A pager for iterating through ``list_vpc_flow_logs_configs`` requests. + + This class thinly wraps an initial + :class:`google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``vpc_flow_logs_configs`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListVpcFlowLogsConfigs`` requests and continue to iterate + through the ``vpc_flow_logs_configs`` field on the + corresponding responses. + + All the usual :class:`google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsResponse` + 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[vpc_flow_logs.ListVpcFlowLogsConfigsResponse]], + request: vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + response: vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest): + The initial request object. + response (google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[vpc_flow_logs.ListVpcFlowLogsConfigsResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__(self) -> AsyncIterator[vpc_flow_logs_config.VpcFlowLogsConfig]: + async def async_generator(): + async for page in self.pages: + for response in page.vpc_flow_logs_configs: + 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-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/README.rst b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/README.rst new file mode 100644 index 000000000000..49b506137650 --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/README.rst @@ -0,0 +1,9 @@ + +transport inheritance structure +_______________________________ + +`OrganizationVpcFlowLogsServiceTransport` is the ABC for all transports. +- public child `OrganizationVpcFlowLogsServiceGrpcTransport` for sync gRPC transport (defined in `grpc.py`). +- public child `OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport` for async gRPC transport (defined in `grpc_asyncio.py`). +- private child `_BaseOrganizationVpcFlowLogsServiceRestTransport` for base REST transport with inner classes `_BaseMETHOD` (defined in `rest_base.py`). +- public child `OrganizationVpcFlowLogsServiceRestTransport` for sync REST transport with inner classes `METHOD` derived from the parent's corresponding `_BaseMETHOD` classes (defined in `rest.py`). diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/__init__.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/__init__.py new file mode 100644 index 000000000000..e0d64c882e70 --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/__init__.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +from typing import Dict, Type + +from .base import OrganizationVpcFlowLogsServiceTransport +from .grpc import OrganizationVpcFlowLogsServiceGrpcTransport +from .grpc_asyncio import OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport +from .rest import ( + OrganizationVpcFlowLogsServiceRestInterceptor, + OrganizationVpcFlowLogsServiceRestTransport, +) + +# Compile a registry of transports. +_transport_registry = ( + OrderedDict() +) # type: Dict[str, Type[OrganizationVpcFlowLogsServiceTransport]] +_transport_registry["grpc"] = OrganizationVpcFlowLogsServiceGrpcTransport +_transport_registry["grpc_asyncio"] = OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport +_transport_registry["rest"] = OrganizationVpcFlowLogsServiceRestTransport + +__all__ = ( + "OrganizationVpcFlowLogsServiceTransport", + "OrganizationVpcFlowLogsServiceGrpcTransport", + "OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport", + "OrganizationVpcFlowLogsServiceRestTransport", + "OrganizationVpcFlowLogsServiceRestInterceptor", +) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/base.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/base.py new file mode 100644 index 000000000000..5310ad7de9e4 --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/base.py @@ -0,0 +1,366 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import abc +from typing import Awaitable, Callable, Dict, Optional, Sequence, Union + +import google.api_core +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1, operations_v1 +from google.api_core import retry as retries +import google.auth # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.oauth2 import service_account # type: ignore +import google.protobuf + +from google.cloud.network_management_v1 import gapic_version as package_version +from google.cloud.network_management_v1.types import vpc_flow_logs, vpc_flow_logs_config + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=package_version.__version__ +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + + +class OrganizationVpcFlowLogsServiceTransport(abc.ABC): + """Abstract transport class for OrganizationVpcFlowLogsService.""" + + AUTH_SCOPES = ("https://www.googleapis.com/auth/cloud-platform",) + + DEFAULT_HOST: str = "networkmanagement.googleapis.com" + + def __init__( + self, + *, + host: str = DEFAULT_HOST, + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + api_audience: Optional[str] = None, + **kwargs, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'networkmanagement.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is mutually exclusive with credentials. This argument will be + removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A list of scopes. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + """ + + scopes_kwargs = {"scopes": scopes, "default_scopes": self.AUTH_SCOPES} + + # Save the scopes. + self._scopes = scopes + if not hasattr(self, "_ignore_credentials"): + self._ignore_credentials: bool = False + + # If no credentials are provided, then determine the appropriate + # defaults. + if credentials and credentials_file: + raise core_exceptions.DuplicateCredentialArgs( + "'credentials_file' and 'credentials' are mutually exclusive" + ) + + if credentials_file is not None: + credentials, _ = google.auth.load_credentials_from_file( + credentials_file, **scopes_kwargs, quota_project_id=quota_project_id + ) + elif credentials is None and not self._ignore_credentials: + credentials, _ = google.auth.default( + **scopes_kwargs, quota_project_id=quota_project_id + ) + # Don't apply audience if the credentials file passed from user. + if hasattr(credentials, "with_gdch_audience"): + credentials = credentials.with_gdch_audience( + api_audience if api_audience else host + ) + + # If the credentials are service account credentials, then always try to use self signed JWT. + if ( + always_use_jwt_access + and isinstance(credentials, service_account.Credentials) + and hasattr(service_account.Credentials, "with_always_use_jwt_access") + ): + credentials = credentials.with_always_use_jwt_access(True) + + # Save the credentials. + self._credentials = credentials + + # Save the hostname. Default to port 443 (HTTPS) if none is specified. + if ":" not in host: + host += ":443" + self._host = host + + @property + def host(self): + return self._host + + def _prep_wrapped_messages(self, client_info): + # Precompute the wrapped methods. + self._wrapped_methods = { + self.list_vpc_flow_logs_configs: gapic_v1.method.wrap_method( + self.list_vpc_flow_logs_configs, + default_timeout=None, + client_info=client_info, + ), + self.get_vpc_flow_logs_config: gapic_v1.method.wrap_method( + self.get_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.create_vpc_flow_logs_config: gapic_v1.method.wrap_method( + self.create_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.update_vpc_flow_logs_config: gapic_v1.method.wrap_method( + self.update_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.delete_vpc_flow_logs_config: gapic_v1.method.wrap_method( + self.delete_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.get_location: gapic_v1.method.wrap_method( + self.get_location, + default_timeout=None, + client_info=client_info, + ), + self.list_locations: gapic_v1.method.wrap_method( + self.list_locations, + default_timeout=None, + client_info=client_info, + ), + self.get_iam_policy: gapic_v1.method.wrap_method( + self.get_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.set_iam_policy: gapic_v1.method.wrap_method( + self.set_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.test_iam_permissions: gapic_v1.method.wrap_method( + self.test_iam_permissions, + default_timeout=None, + client_info=client_info, + ), + self.cancel_operation: gapic_v1.method.wrap_method( + self.cancel_operation, + default_timeout=None, + client_info=client_info, + ), + self.delete_operation: gapic_v1.method.wrap_method( + self.delete_operation, + default_timeout=None, + client_info=client_info, + ), + self.get_operation: gapic_v1.method.wrap_method( + self.get_operation, + default_timeout=None, + client_info=client_info, + ), + self.list_operations: gapic_v1.method.wrap_method( + self.list_operations, + default_timeout=None, + client_info=client_info, + ), + } + + def close(self): + """Closes resources associated with the transport. + + .. warning:: + Only call this method if the transport is NOT shared + with other clients - this may cause errors in other clients! + """ + raise NotImplementedError() + + @property + def operations_client(self): + """Return the client designed to process long-running operations.""" + raise NotImplementedError() + + @property + def list_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ListVpcFlowLogsConfigsRequest], + Union[ + vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + Awaitable[vpc_flow_logs.ListVpcFlowLogsConfigsResponse], + ], + ]: + raise NotImplementedError() + + @property + def get_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.GetVpcFlowLogsConfigRequest], + Union[ + vpc_flow_logs_config.VpcFlowLogsConfig, + Awaitable[vpc_flow_logs_config.VpcFlowLogsConfig], + ], + ]: + raise NotImplementedError() + + @property + def create_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.CreateVpcFlowLogsConfigRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def update_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.UpdateVpcFlowLogsConfigRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def delete_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.DeleteVpcFlowLogsConfigRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def list_operations( + self, + ) -> Callable[ + [operations_pb2.ListOperationsRequest], + Union[ + operations_pb2.ListOperationsResponse, + Awaitable[operations_pb2.ListOperationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def get_operation( + self, + ) -> Callable[ + [operations_pb2.GetOperationRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def cancel_operation( + self, + ) -> Callable[[operations_pb2.CancelOperationRequest], None,]: + raise NotImplementedError() + + @property + def delete_operation( + self, + ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]: + raise NotImplementedError() + + @property + def set_iam_policy( + self, + ) -> Callable[ + [iam_policy_pb2.SetIamPolicyRequest], + Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]], + ]: + raise NotImplementedError() + + @property + def get_iam_policy( + self, + ) -> Callable[ + [iam_policy_pb2.GetIamPolicyRequest], + Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]], + ]: + raise NotImplementedError() + + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + Union[ + iam_policy_pb2.TestIamPermissionsResponse, + Awaitable[iam_policy_pb2.TestIamPermissionsResponse], + ], + ]: + raise NotImplementedError() + + @property + def get_location( + self, + ) -> Callable[ + [locations_pb2.GetLocationRequest], + Union[locations_pb2.Location, Awaitable[locations_pb2.Location]], + ]: + raise NotImplementedError() + + @property + def list_locations( + self, + ) -> Callable[ + [locations_pb2.ListLocationsRequest], + Union[ + locations_pb2.ListLocationsResponse, + Awaitable[locations_pb2.ListLocationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def kind(self) -> str: + raise NotImplementedError() + + +__all__ = ("OrganizationVpcFlowLogsServiceTransport",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/grpc.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/grpc.py new file mode 100644 index 000000000000..5af1c99eb49c --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/grpc.py @@ -0,0 +1,722 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import json +import logging as std_logging +import pickle +from typing import Callable, Dict, Optional, Sequence, Tuple, Union +import warnings + +from google.api_core import gapic_v1, grpc_helpers, operations_v1 +import google.auth # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf.json_format import MessageToJson +import google.protobuf.message +import grpc # type: ignore +import proto # type: ignore + +from google.cloud.network_management_v1.types import vpc_flow_logs, vpc_flow_logs_config + +from .base import DEFAULT_CLIENT_INFO, OrganizationVpcFlowLogsServiceTransport + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + + +class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER + def intercept_unary_unary(self, continuation, client_call_details, request): + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ) + if logging_enabled: # pragma: NO COVER + request_metadata = client_call_details.metadata + if isinstance(request, proto.Message): + request_payload = type(request).to_json(request) + elif isinstance(request, google.protobuf.message.Message): + request_payload = MessageToJson(request) + else: + request_payload = f"{type(request).__name__}: {pickle.dumps(request)}" + + request_metadata = { + key: value.decode("utf-8") if isinstance(value, bytes) else value + for key, value in request_metadata + } + grpc_request = { + "payload": request_payload, + "requestMethod": "grpc", + "metadata": dict(request_metadata), + } + _LOGGER.debug( + f"Sending request for {client_call_details.method}", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": str(client_call_details.method), + "request": grpc_request, + "metadata": grpc_request["metadata"], + }, + ) + response = continuation(client_call_details, request) + if logging_enabled: # pragma: NO COVER + response_metadata = response.trailing_metadata() + # Convert gRPC metadata `` to list of tuples + metadata = ( + dict([(k, str(v)) for k, v in response_metadata]) + if response_metadata + else None + ) + result = response.result() + if isinstance(result, proto.Message): + response_payload = type(result).to_json(result) + elif isinstance(result, google.protobuf.message.Message): + response_payload = MessageToJson(result) + else: + response_payload = f"{type(result).__name__}: {pickle.dumps(result)}" + grpc_response = { + "payload": response_payload, + "metadata": metadata, + "status": "OK", + } + _LOGGER.debug( + f"Received response for {client_call_details.method}.", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": client_call_details.method, + "response": grpc_response, + "metadata": grpc_response["metadata"], + }, + ) + return response + + +class OrganizationVpcFlowLogsServiceGrpcTransport( + OrganizationVpcFlowLogsServiceTransport +): + """gRPC backend transport for OrganizationVpcFlowLogsService. + + The VPC Flow Logs organization service in the Google Cloud + Network Management API provides organization level + configurations that generate Flow Logs. The service and the + configuration resources created using this service are global. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends protocol buffers over the wire using gRPC (which is built on + top of HTTP/2); the ``grpcio`` package must be installed. + """ + + _stubs: Dict[str, Callable] + + def __init__( + self, + *, + host: str = "networkmanagement.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + channel: Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]] = None, + api_mtls_endpoint: Optional[str] = None, + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'networkmanagement.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is ignored if a ``channel`` instance is provided. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if a ``channel`` instance is provided. + This argument will be removed in the next major version of this library. + scopes (Optional(Sequence[str])): A list of scopes. This argument is + ignored if a ``channel`` instance is provided. + channel (Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]]): + A ``Channel`` instance through which to make calls, or a Callable + that constructs and returns one. If set to None, ``self.create_channel`` + is used to create the channel. If a Callable is given, it will be called + with the same arguments as used in ``self.create_channel``. + api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint. + If provided, it overrides the ``host`` argument and tries to create + a mutual TLS channel with client SSL credentials from + ``client_cert_source`` or application default SSL credentials. + client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): + Deprecated. A callback to provide client SSL certificate bytes and + private key bytes, both in PEM format. It is ignored if + ``api_mtls_endpoint`` is None. + ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials + for the grpc channel. It is ignored if a ``channel`` instance is provided. + client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]): + A callback to provide client certificate bytes and private key bytes, + both in PEM format. It is used to configure a mutual TLS channel. It is + ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport + creation failed for any reason. + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + self._grpc_channel = None + self._ssl_channel_credentials = ssl_channel_credentials + self._stubs: Dict[str, Callable] = {} + self._operations_client: Optional[operations_v1.OperationsClient] = None + + if api_mtls_endpoint: + warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning) + if client_cert_source: + warnings.warn("client_cert_source is deprecated", DeprecationWarning) + + if isinstance(channel, grpc.Channel): + # Ignore credentials if a channel was passed. + credentials = None + self._ignore_credentials = True + # If a channel was explicitly provided, set it. + self._grpc_channel = channel + self._ssl_channel_credentials = None + + else: + if api_mtls_endpoint: + host = api_mtls_endpoint + + # Create SSL credentials with client_cert_source or application + # default SSL credentials. + if client_cert_source: + cert, key = client_cert_source() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + else: + self._ssl_channel_credentials = SslCredentials().ssl_credentials + + else: + if client_cert_source_for_mtls and not ssl_channel_credentials: + cert, key = client_cert_source_for_mtls() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + + # The base transport sets the host, credentials and scopes + super().__init__( + host=host, + credentials=credentials, + credentials_file=credentials_file, + scopes=scopes, + quota_project_id=quota_project_id, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + + if not self._grpc_channel: + # initialize with the provided callable or the default channel + channel_init = channel or type(self).create_channel + self._grpc_channel = channel_init( + self._host, + # use the credentials which are saved + credentials=self._credentials, + # Set ``credentials_file`` to ``None`` here as + # the credentials that we saved earlier should be used. + credentials_file=None, + scopes=self._scopes, + ssl_credentials=self._ssl_channel_credentials, + quota_project_id=quota_project_id, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + self._interceptor = _LoggingClientInterceptor() + self._logged_channel = grpc.intercept_channel( + self._grpc_channel, self._interceptor + ) + + # Wrap messages. This must be done after self._logged_channel exists + self._prep_wrapped_messages(client_info) + + @classmethod + def create_channel( + cls, + host: str = "networkmanagement.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + **kwargs, + ) -> grpc.Channel: + """Create and return a gRPC channel object. + Args: + host (Optional[str]): The host for the channel to use. + credentials (Optional[~.Credentials]): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is mutually exclusive with credentials. This argument will be + removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + kwargs (Optional[dict]): Keyword arguments, which are passed to the + channel creation. + Returns: + grpc.Channel: A gRPC channel object. + + Raises: + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + + return grpc_helpers.create_channel( + host, + credentials=credentials, + credentials_file=credentials_file, + quota_project_id=quota_project_id, + default_scopes=cls.AUTH_SCOPES, + scopes=scopes, + default_host=cls.DEFAULT_HOST, + **kwargs, + ) + + @property + def grpc_channel(self) -> grpc.Channel: + """Return the channel designed to connect to this service.""" + return self._grpc_channel + + @property + def operations_client(self) -> operations_v1.OperationsClient: + """Create the client designed to process long-running operations. + + This property caches on the instance; repeated calls return the same + client. + """ + # Quick check: Only create a new client if we do not already have one. + if self._operations_client is None: + self._operations_client = operations_v1.OperationsClient( + self._logged_channel + ) + + # Return the client from cache. + return self._operations_client + + @property + def list_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ListVpcFlowLogsConfigsRequest], + vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + ]: + r"""Return a callable for the list vpc flow logs configs method over gRPC. + + Lists all ``VpcFlowLogsConfigs`` in a given organization. + + Returns: + Callable[[~.ListVpcFlowLogsConfigsRequest], + ~.ListVpcFlowLogsConfigsResponse]: + 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_vpc_flow_logs_configs" not in self._stubs: + self._stubs[ + "list_vpc_flow_logs_configs" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/ListVpcFlowLogsConfigs", + request_serializer=vpc_flow_logs.ListVpcFlowLogsConfigsRequest.serialize, + response_deserializer=vpc_flow_logs.ListVpcFlowLogsConfigsResponse.deserialize, + ) + return self._stubs["list_vpc_flow_logs_configs"] + + @property + def get_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.GetVpcFlowLogsConfigRequest], + vpc_flow_logs_config.VpcFlowLogsConfig, + ]: + r"""Return a callable for the get vpc flow logs config method over gRPC. + + Gets the details of a specific ``VpcFlowLogsConfig``. + + Returns: + Callable[[~.GetVpcFlowLogsConfigRequest], + ~.VpcFlowLogsConfig]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_vpc_flow_logs_config" not in self._stubs: + self._stubs["get_vpc_flow_logs_config"] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/GetVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.GetVpcFlowLogsConfigRequest.serialize, + response_deserializer=vpc_flow_logs_config.VpcFlowLogsConfig.deserialize, + ) + return self._stubs["get_vpc_flow_logs_config"] + + @property + def create_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.CreateVpcFlowLogsConfigRequest], operations_pb2.Operation + ]: + r"""Return a callable for the create vpc flow logs config method over gRPC. + + Creates a new ``VpcFlowLogsConfig``. If a configuration with the + exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + Returns: + Callable[[~.CreateVpcFlowLogsConfigRequest], + ~.Operation]: + 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 "create_vpc_flow_logs_config" not in self._stubs: + self._stubs[ + "create_vpc_flow_logs_config" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/CreateVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.CreateVpcFlowLogsConfigRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["create_vpc_flow_logs_config"] + + @property + def update_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.UpdateVpcFlowLogsConfigRequest], operations_pb2.Operation + ]: + r"""Return a callable for the update vpc flow logs config method over gRPC. + + Updates an existing ``VpcFlowLogsConfig``. If a configuration + with the exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Updating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + Returns: + Callable[[~.UpdateVpcFlowLogsConfigRequest], + ~.Operation]: + 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 "update_vpc_flow_logs_config" not in self._stubs: + self._stubs[ + "update_vpc_flow_logs_config" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/UpdateVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["update_vpc_flow_logs_config"] + + @property + def delete_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.DeleteVpcFlowLogsConfigRequest], operations_pb2.Operation + ]: + r"""Return a callable for the delete vpc flow logs config method over gRPC. + + Deletes a specific ``VpcFlowLogsConfig``. + + Returns: + Callable[[~.DeleteVpcFlowLogsConfigRequest], + ~.Operation]: + 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 "delete_vpc_flow_logs_config" not in self._stubs: + self._stubs[ + "delete_vpc_flow_logs_config" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/DeleteVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["delete_vpc_flow_logs_config"] + + def close(self): + self._logged_channel.close() + + @property + def delete_operation( + self, + ) -> Callable[[operations_pb2.DeleteOperationRequest], None]: + r"""Return a callable for the delete_operation method over gRPC.""" + # 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 "delete_operation" not in self._stubs: + self._stubs["delete_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/DeleteOperation", + request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["delete_operation"] + + @property + def cancel_operation( + self, + ) -> Callable[[operations_pb2.CancelOperationRequest], None]: + r"""Return a callable for the cancel_operation method over gRPC.""" + # 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 "cancel_operation" not in self._stubs: + self._stubs["cancel_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/CancelOperation", + request_serializer=operations_pb2.CancelOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["cancel_operation"] + + @property + def get_operation( + self, + ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]: + r"""Return a callable for the get_operation method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_operation" not in self._stubs: + self._stubs["get_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/GetOperation", + request_serializer=operations_pb2.GetOperationRequest.SerializeToString, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["get_operation"] + + @property + def list_operations( + self, + ) -> Callable[ + [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse + ]: + r"""Return a callable for the list_operations method over gRPC.""" + # 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_operations" not in self._stubs: + self._stubs["list_operations"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/ListOperations", + request_serializer=operations_pb2.ListOperationsRequest.SerializeToString, + response_deserializer=operations_pb2.ListOperationsResponse.FromString, + ) + return self._stubs["list_operations"] + + @property + def list_locations( + self, + ) -> Callable[ + [locations_pb2.ListLocationsRequest], locations_pb2.ListLocationsResponse + ]: + r"""Return a callable for the list locations method over gRPC.""" + # 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_locations" not in self._stubs: + self._stubs["list_locations"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/ListLocations", + request_serializer=locations_pb2.ListLocationsRequest.SerializeToString, + response_deserializer=locations_pb2.ListLocationsResponse.FromString, + ) + return self._stubs["list_locations"] + + @property + def get_location( + self, + ) -> Callable[[locations_pb2.GetLocationRequest], locations_pb2.Location]: + r"""Return a callable for the list locations method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_location" not in self._stubs: + self._stubs["get_location"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/GetLocation", + request_serializer=locations_pb2.GetLocationRequest.SerializeToString, + response_deserializer=locations_pb2.Location.FromString, + ) + return self._stubs["get_location"] + + @property + def set_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]: + r"""Return a callable for the set iam policy method over gRPC. + Sets the IAM access control policy on the specified + function. Replaces any existing policy. + Returns: + Callable[[~.SetIamPolicyRequest], + ~.Policy]: + 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 "set_iam_policy" not in self._stubs: + self._stubs["set_iam_policy"] = self._logged_channel.unary_unary( + "/google.iam.v1.IAMPolicy/SetIamPolicy", + request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["set_iam_policy"] + + @property + def get_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]: + r"""Return a callable for the get iam policy method over gRPC. + Gets the IAM access control policy for a function. + Returns an empty policy if the function exists and does + not have a policy set. + Returns: + Callable[[~.GetIamPolicyRequest], + ~.Policy]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_iam_policy" not in self._stubs: + self._stubs["get_iam_policy"] = self._logged_channel.unary_unary( + "/google.iam.v1.IAMPolicy/GetIamPolicy", + request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["get_iam_policy"] + + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + iam_policy_pb2.TestIamPermissionsResponse, + ]: + r"""Return a callable for the test iam permissions method over gRPC. + Tests the specified permissions against the IAM access control + policy for a function. If the function does not exist, this will + return an empty set of permissions, not a NOT_FOUND error. + Returns: + Callable[[~.TestIamPermissionsRequest], + ~.TestIamPermissionsResponse]: + 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 "test_iam_permissions" not in self._stubs: + self._stubs["test_iam_permissions"] = self._logged_channel.unary_unary( + "/google.iam.v1.IAMPolicy/TestIamPermissions", + request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString, + response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString, + ) + return self._stubs["test_iam_permissions"] + + @property + def kind(self) -> str: + return "grpc" + + +__all__ = ("OrganizationVpcFlowLogsServiceGrpcTransport",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/grpc_asyncio.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/grpc_asyncio.py new file mode 100644 index 000000000000..4c40ab2ca76c --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/grpc_asyncio.py @@ -0,0 +1,813 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import inspect +import json +import logging as std_logging +import pickle +from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union +import warnings + +from google.api_core import exceptions as core_exceptions +from google.api_core import gapic_v1, grpc_helpers_async, operations_v1 +from google.api_core import retry_async as retries +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf.json_format import MessageToJson +import google.protobuf.message +import grpc # type: ignore +from grpc.experimental import aio # type: ignore +import proto # type: ignore + +from google.cloud.network_management_v1.types import vpc_flow_logs, vpc_flow_logs_config + +from .base import DEFAULT_CLIENT_INFO, OrganizationVpcFlowLogsServiceTransport +from .grpc import OrganizationVpcFlowLogsServiceGrpcTransport + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = std_logging.getLogger(__name__) + + +class _LoggingClientAIOInterceptor( + grpc.aio.UnaryUnaryClientInterceptor +): # pragma: NO COVER + async def intercept_unary_unary(self, continuation, client_call_details, request): + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + std_logging.DEBUG + ) + if logging_enabled: # pragma: NO COVER + request_metadata = client_call_details.metadata + if isinstance(request, proto.Message): + request_payload = type(request).to_json(request) + elif isinstance(request, google.protobuf.message.Message): + request_payload = MessageToJson(request) + else: + request_payload = f"{type(request).__name__}: {pickle.dumps(request)}" + + request_metadata = { + key: value.decode("utf-8") if isinstance(value, bytes) else value + for key, value in request_metadata + } + grpc_request = { + "payload": request_payload, + "requestMethod": "grpc", + "metadata": dict(request_metadata), + } + _LOGGER.debug( + f"Sending request for {client_call_details.method}", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": str(client_call_details.method), + "request": grpc_request, + "metadata": grpc_request["metadata"], + }, + ) + response = await continuation(client_call_details, request) + if logging_enabled: # pragma: NO COVER + response_metadata = await response.trailing_metadata() + # Convert gRPC metadata `` to list of tuples + metadata = ( + dict([(k, str(v)) for k, v in response_metadata]) + if response_metadata + else None + ) + result = await response + if isinstance(result, proto.Message): + response_payload = type(result).to_json(result) + elif isinstance(result, google.protobuf.message.Message): + response_payload = MessageToJson(result) + else: + response_payload = f"{type(result).__name__}: {pickle.dumps(result)}" + grpc_response = { + "payload": response_payload, + "metadata": metadata, + "status": "OK", + } + _LOGGER.debug( + f"Received response to rpc {client_call_details.method}.", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": str(client_call_details.method), + "response": grpc_response, + "metadata": grpc_response["metadata"], + }, + ) + return response + + +class OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport( + OrganizationVpcFlowLogsServiceTransport +): + """gRPC AsyncIO backend transport for OrganizationVpcFlowLogsService. + + The VPC Flow Logs organization service in the Google Cloud + Network Management API provides organization level + configurations that generate Flow Logs. The service and the + configuration resources created using this service are global. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends protocol buffers over the wire using gRPC (which is built on + top of HTTP/2); the ``grpcio`` package must be installed. + """ + + _grpc_channel: aio.Channel + _stubs: Dict[str, Callable] = {} + + @classmethod + def create_channel( + cls, + host: str = "networkmanagement.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + **kwargs, + ) -> aio.Channel: + """Create and return a gRPC AsyncIO channel object. + Args: + host (Optional[str]): The host for the channel to use. + credentials (Optional[~.Credentials]): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. This argument will be + removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + kwargs (Optional[dict]): Keyword arguments, which are passed to the + channel creation. + Returns: + aio.Channel: A gRPC AsyncIO channel object. + """ + + return grpc_helpers_async.create_channel( + host, + credentials=credentials, + credentials_file=credentials_file, + quota_project_id=quota_project_id, + default_scopes=cls.AUTH_SCOPES, + scopes=scopes, + default_host=cls.DEFAULT_HOST, + **kwargs, + ) + + def __init__( + self, + *, + host: str = "networkmanagement.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + channel: Optional[Union[aio.Channel, Callable[..., aio.Channel]]] = None, + api_mtls_endpoint: Optional[str] = None, + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'networkmanagement.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is ignored if a ``channel`` instance is provided. + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if a ``channel`` instance is provided. + This argument will be removed in the next major version of this library. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + channel (Optional[Union[aio.Channel, Callable[..., aio.Channel]]]): + A ``Channel`` instance through which to make calls, or a Callable + that constructs and returns one. If set to None, ``self.create_channel`` + is used to create the channel. If a Callable is given, it will be called + with the same arguments as used in ``self.create_channel``. + api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint. + If provided, it overrides the ``host`` argument and tries to create + a mutual TLS channel with client SSL credentials from + ``client_cert_source`` or application default SSL credentials. + client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): + Deprecated. A callback to provide client SSL certificate bytes and + private key bytes, both in PEM format. It is ignored if + ``api_mtls_endpoint`` is None. + ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials + for the grpc channel. It is ignored if a ``channel`` instance is provided. + client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]): + A callback to provide client certificate bytes and private key bytes, + both in PEM format. It is used to configure a mutual TLS channel. It is + ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + + Raises: + google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport + creation failed for any reason. + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + self._grpc_channel = None + self._ssl_channel_credentials = ssl_channel_credentials + self._stubs: Dict[str, Callable] = {} + self._operations_client: Optional[operations_v1.OperationsAsyncClient] = None + + if api_mtls_endpoint: + warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning) + if client_cert_source: + warnings.warn("client_cert_source is deprecated", DeprecationWarning) + + if isinstance(channel, aio.Channel): + # Ignore credentials if a channel was passed. + credentials = None + self._ignore_credentials = True + # If a channel was explicitly provided, set it. + self._grpc_channel = channel + self._ssl_channel_credentials = None + else: + if api_mtls_endpoint: + host = api_mtls_endpoint + + # Create SSL credentials with client_cert_source or application + # default SSL credentials. + if client_cert_source: + cert, key = client_cert_source() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + else: + self._ssl_channel_credentials = SslCredentials().ssl_credentials + + else: + if client_cert_source_for_mtls and not ssl_channel_credentials: + cert, key = client_cert_source_for_mtls() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + + # The base transport sets the host, credentials and scopes + super().__init__( + host=host, + credentials=credentials, + credentials_file=credentials_file, + scopes=scopes, + quota_project_id=quota_project_id, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + + if not self._grpc_channel: + # initialize with the provided callable or the default channel + channel_init = channel or type(self).create_channel + self._grpc_channel = channel_init( + self._host, + # use the credentials which are saved + credentials=self._credentials, + # Set ``credentials_file`` to ``None`` here as + # the credentials that we saved earlier should be used. + credentials_file=None, + scopes=self._scopes, + ssl_credentials=self._ssl_channel_credentials, + quota_project_id=quota_project_id, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + self._interceptor = _LoggingClientAIOInterceptor() + self._grpc_channel._unary_unary_interceptors.append(self._interceptor) + self._logged_channel = self._grpc_channel + self._wrap_with_kind = ( + "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters + ) + # Wrap messages. This must be done after self._logged_channel exists + self._prep_wrapped_messages(client_info) + + @property + def grpc_channel(self) -> aio.Channel: + """Create the channel designed to connect to this service. + + This property caches on the instance; repeated calls return + the same channel. + """ + # Return the channel from cache. + return self._grpc_channel + + @property + def operations_client(self) -> operations_v1.OperationsAsyncClient: + """Create the client designed to process long-running operations. + + This property caches on the instance; repeated calls return the same + client. + """ + # Quick check: Only create a new client if we do not already have one. + if self._operations_client is None: + self._operations_client = operations_v1.OperationsAsyncClient( + self._logged_channel + ) + + # Return the client from cache. + return self._operations_client + + @property + def list_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ListVpcFlowLogsConfigsRequest], + Awaitable[vpc_flow_logs.ListVpcFlowLogsConfigsResponse], + ]: + r"""Return a callable for the list vpc flow logs configs method over gRPC. + + Lists all ``VpcFlowLogsConfigs`` in a given organization. + + Returns: + Callable[[~.ListVpcFlowLogsConfigsRequest], + Awaitable[~.ListVpcFlowLogsConfigsResponse]]: + 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_vpc_flow_logs_configs" not in self._stubs: + self._stubs[ + "list_vpc_flow_logs_configs" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/ListVpcFlowLogsConfigs", + request_serializer=vpc_flow_logs.ListVpcFlowLogsConfigsRequest.serialize, + response_deserializer=vpc_flow_logs.ListVpcFlowLogsConfigsResponse.deserialize, + ) + return self._stubs["list_vpc_flow_logs_configs"] + + @property + def get_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.GetVpcFlowLogsConfigRequest], + Awaitable[vpc_flow_logs_config.VpcFlowLogsConfig], + ]: + r"""Return a callable for the get vpc flow logs config method over gRPC. + + Gets the details of a specific ``VpcFlowLogsConfig``. + + Returns: + Callable[[~.GetVpcFlowLogsConfigRequest], + Awaitable[~.VpcFlowLogsConfig]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_vpc_flow_logs_config" not in self._stubs: + self._stubs["get_vpc_flow_logs_config"] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/GetVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.GetVpcFlowLogsConfigRequest.serialize, + response_deserializer=vpc_flow_logs_config.VpcFlowLogsConfig.deserialize, + ) + return self._stubs["get_vpc_flow_logs_config"] + + @property + def create_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.CreateVpcFlowLogsConfigRequest], + Awaitable[operations_pb2.Operation], + ]: + r"""Return a callable for the create vpc flow logs config method over gRPC. + + Creates a new ``VpcFlowLogsConfig``. If a configuration with the + exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + Returns: + Callable[[~.CreateVpcFlowLogsConfigRequest], + Awaitable[~.Operation]]: + 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 "create_vpc_flow_logs_config" not in self._stubs: + self._stubs[ + "create_vpc_flow_logs_config" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/CreateVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.CreateVpcFlowLogsConfigRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["create_vpc_flow_logs_config"] + + @property + def update_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.UpdateVpcFlowLogsConfigRequest], + Awaitable[operations_pb2.Operation], + ]: + r"""Return a callable for the update vpc flow logs config method over gRPC. + + Updates an existing ``VpcFlowLogsConfig``. If a configuration + with the exact same settings already exists (even if the ID is + different), the creation fails. Notes: + + 1. Updating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: + + - name + - create_time + - update_time + - labels + - description + + Returns: + Callable[[~.UpdateVpcFlowLogsConfigRequest], + Awaitable[~.Operation]]: + 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 "update_vpc_flow_logs_config" not in self._stubs: + self._stubs[ + "update_vpc_flow_logs_config" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/UpdateVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["update_vpc_flow_logs_config"] + + @property + def delete_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.DeleteVpcFlowLogsConfigRequest], + Awaitable[operations_pb2.Operation], + ]: + r"""Return a callable for the delete vpc flow logs config method over gRPC. + + Deletes a specific ``VpcFlowLogsConfig``. + + Returns: + Callable[[~.DeleteVpcFlowLogsConfigRequest], + Awaitable[~.Operation]]: + 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 "delete_vpc_flow_logs_config" not in self._stubs: + self._stubs[ + "delete_vpc_flow_logs_config" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService/DeleteVpcFlowLogsConfig", + request_serializer=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["delete_vpc_flow_logs_config"] + + def _prep_wrapped_messages(self, client_info): + """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" + self._wrapped_methods = { + self.list_vpc_flow_logs_configs: self._wrap_method( + self.list_vpc_flow_logs_configs, + default_timeout=None, + client_info=client_info, + ), + self.get_vpc_flow_logs_config: self._wrap_method( + self.get_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.create_vpc_flow_logs_config: self._wrap_method( + self.create_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.update_vpc_flow_logs_config: self._wrap_method( + self.update_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.delete_vpc_flow_logs_config: self._wrap_method( + self.delete_vpc_flow_logs_config, + default_timeout=None, + client_info=client_info, + ), + self.get_location: self._wrap_method( + self.get_location, + default_timeout=None, + client_info=client_info, + ), + self.list_locations: self._wrap_method( + self.list_locations, + default_timeout=None, + client_info=client_info, + ), + self.get_iam_policy: self._wrap_method( + self.get_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.set_iam_policy: self._wrap_method( + self.set_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.test_iam_permissions: self._wrap_method( + self.test_iam_permissions, + default_timeout=None, + client_info=client_info, + ), + self.cancel_operation: self._wrap_method( + self.cancel_operation, + default_timeout=None, + client_info=client_info, + ), + self.delete_operation: self._wrap_method( + self.delete_operation, + default_timeout=None, + client_info=client_info, + ), + self.get_operation: self._wrap_method( + self.get_operation, + default_timeout=None, + client_info=client_info, + ), + self.list_operations: self._wrap_method( + self.list_operations, + default_timeout=None, + client_info=client_info, + ), + } + + def _wrap_method(self, func, *args, **kwargs): + if self._wrap_with_kind: # pragma: NO COVER + kwargs["kind"] = self.kind + return gapic_v1.method_async.wrap_method(func, *args, **kwargs) + + def close(self): + return self._logged_channel.close() + + @property + def kind(self) -> str: + return "grpc_asyncio" + + @property + def delete_operation( + self, + ) -> Callable[[operations_pb2.DeleteOperationRequest], None]: + r"""Return a callable for the delete_operation method over gRPC.""" + # 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 "delete_operation" not in self._stubs: + self._stubs["delete_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/DeleteOperation", + request_serializer=operations_pb2.DeleteOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["delete_operation"] + + @property + def cancel_operation( + self, + ) -> Callable[[operations_pb2.CancelOperationRequest], None]: + r"""Return a callable for the cancel_operation method over gRPC.""" + # 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 "cancel_operation" not in self._stubs: + self._stubs["cancel_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/CancelOperation", + request_serializer=operations_pb2.CancelOperationRequest.SerializeToString, + response_deserializer=None, + ) + return self._stubs["cancel_operation"] + + @property + def get_operation( + self, + ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]: + r"""Return a callable for the get_operation method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_operation" not in self._stubs: + self._stubs["get_operation"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/GetOperation", + request_serializer=operations_pb2.GetOperationRequest.SerializeToString, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["get_operation"] + + @property + def list_operations( + self, + ) -> Callable[ + [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse + ]: + r"""Return a callable for the list_operations method over gRPC.""" + # 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_operations" not in self._stubs: + self._stubs["list_operations"] = self._logged_channel.unary_unary( + "/google.longrunning.Operations/ListOperations", + request_serializer=operations_pb2.ListOperationsRequest.SerializeToString, + response_deserializer=operations_pb2.ListOperationsResponse.FromString, + ) + return self._stubs["list_operations"] + + @property + def list_locations( + self, + ) -> Callable[ + [locations_pb2.ListLocationsRequest], locations_pb2.ListLocationsResponse + ]: + r"""Return a callable for the list locations method over gRPC.""" + # 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_locations" not in self._stubs: + self._stubs["list_locations"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/ListLocations", + request_serializer=locations_pb2.ListLocationsRequest.SerializeToString, + response_deserializer=locations_pb2.ListLocationsResponse.FromString, + ) + return self._stubs["list_locations"] + + @property + def get_location( + self, + ) -> Callable[[locations_pb2.GetLocationRequest], locations_pb2.Location]: + r"""Return a callable for the list locations method over gRPC.""" + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_location" not in self._stubs: + self._stubs["get_location"] = self._logged_channel.unary_unary( + "/google.cloud.location.Locations/GetLocation", + request_serializer=locations_pb2.GetLocationRequest.SerializeToString, + response_deserializer=locations_pb2.Location.FromString, + ) + return self._stubs["get_location"] + + @property + def set_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]: + r"""Return a callable for the set iam policy method over gRPC. + Sets the IAM access control policy on the specified + function. Replaces any existing policy. + Returns: + Callable[[~.SetIamPolicyRequest], + ~.Policy]: + 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 "set_iam_policy" not in self._stubs: + self._stubs["set_iam_policy"] = self._logged_channel.unary_unary( + "/google.iam.v1.IAMPolicy/SetIamPolicy", + request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["set_iam_policy"] + + @property + def get_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]: + r"""Return a callable for the get iam policy method over gRPC. + Gets the IAM access control policy for a function. + Returns an empty policy if the function exists and does + not have a policy set. + Returns: + Callable[[~.GetIamPolicyRequest], + ~.Policy]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_iam_policy" not in self._stubs: + self._stubs["get_iam_policy"] = self._logged_channel.unary_unary( + "/google.iam.v1.IAMPolicy/GetIamPolicy", + request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["get_iam_policy"] + + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + iam_policy_pb2.TestIamPermissionsResponse, + ]: + r"""Return a callable for the test iam permissions method over gRPC. + Tests the specified permissions against the IAM access control + policy for a function. If the function does not exist, this will + return an empty set of permissions, not a NOT_FOUND error. + Returns: + Callable[[~.TestIamPermissionsRequest], + ~.TestIamPermissionsResponse]: + 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 "test_iam_permissions" not in self._stubs: + self._stubs["test_iam_permissions"] = self._logged_channel.unary_unary( + "/google.iam.v1.IAMPolicy/TestIamPermissions", + request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString, + response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString, + ) + return self._stubs["test_iam_permissions"] + + +__all__ = ("OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/rest.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/rest.py new file mode 100644 index 000000000000..5749da14192e --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/rest.py @@ -0,0 +1,2836 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import dataclasses +import json # type: ignore +import logging +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union +import warnings + +from google.api_core import gapic_v1, operations_v1, rest_helpers, rest_streaming +from google.api_core import exceptions as core_exceptions +from google.api_core import retry as retries +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.requests import AuthorizedSession # type: ignore +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +import google.protobuf +from google.protobuf import json_format +from requests import __version__ as requests_version + +from google.cloud.network_management_v1.types import vpc_flow_logs, vpc_flow_logs_config + +from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO +from .rest_base import _BaseOrganizationVpcFlowLogsServiceRestTransport + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object, None] # type: ignore + +try: + from google.api_core import client_logging # type: ignore + + CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER +except ImportError: # pragma: NO COVER + CLIENT_LOGGING_SUPPORTED = False + +_LOGGER = logging.getLogger(__name__) + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version, + grpc_version=None, + rest_version=f"requests@{requests_version}", +) + +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + + +class OrganizationVpcFlowLogsServiceRestInterceptor: + """Interceptor for OrganizationVpcFlowLogsService. + + Interceptors are used to manipulate requests, request metadata, and responses + in arbitrary ways. + Example use cases include: + * Logging + * Verifying requests according to service or custom semantics + * Stripping extraneous information from responses + + These use cases and more can be enabled by injecting an + instance of a custom subclass when constructing the OrganizationVpcFlowLogsServiceRestTransport. + + .. code-block:: python + class MyCustomOrganizationVpcFlowLogsServiceInterceptor(OrganizationVpcFlowLogsServiceRestInterceptor): + def pre_create_vpc_flow_logs_config(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_vpc_flow_logs_config(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_delete_vpc_flow_logs_config(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_delete_vpc_flow_logs_config(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_get_vpc_flow_logs_config(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_vpc_flow_logs_config(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_list_vpc_flow_logs_configs(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_vpc_flow_logs_configs(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_update_vpc_flow_logs_config(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_vpc_flow_logs_config(self, response): + logging.log(f"Received response: {response}") + return response + + transport = OrganizationVpcFlowLogsServiceRestTransport(interceptor=MyCustomOrganizationVpcFlowLogsServiceInterceptor()) + client = OrganizationVpcFlowLogsServiceClient(transport=transport) + + + """ + + def pre_create_vpc_flow_logs_config( + self, + request: vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for create_vpc_flow_logs_config + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_create_vpc_flow_logs_config( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for create_vpc_flow_logs_config + + DEPRECATED. Please use the `post_create_vpc_flow_logs_config_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. This `post_create_vpc_flow_logs_config` interceptor runs + before the `post_create_vpc_flow_logs_config_with_metadata` interceptor. + """ + return response + + def post_create_vpc_flow_logs_config_with_metadata( + self, + response: operations_pb2.Operation, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[operations_pb2.Operation, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for create_vpc_flow_logs_config + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the OrganizationVpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_create_vpc_flow_logs_config_with_metadata` + interceptor in new development instead of the `post_create_vpc_flow_logs_config` interceptor. + When both interceptors are used, this `post_create_vpc_flow_logs_config_with_metadata` interceptor runs after the + `post_create_vpc_flow_logs_config` interceptor. The (possibly modified) response returned by + `post_create_vpc_flow_logs_config` will be passed to + `post_create_vpc_flow_logs_config_with_metadata`. + """ + return response, metadata + + def pre_delete_vpc_flow_logs_config( + self, + request: vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for delete_vpc_flow_logs_config + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_delete_vpc_flow_logs_config( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for delete_vpc_flow_logs_config + + DEPRECATED. Please use the `post_delete_vpc_flow_logs_config_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. This `post_delete_vpc_flow_logs_config` interceptor runs + before the `post_delete_vpc_flow_logs_config_with_metadata` interceptor. + """ + return response + + def post_delete_vpc_flow_logs_config_with_metadata( + self, + response: operations_pb2.Operation, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[operations_pb2.Operation, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for delete_vpc_flow_logs_config + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the OrganizationVpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_delete_vpc_flow_logs_config_with_metadata` + interceptor in new development instead of the `post_delete_vpc_flow_logs_config` interceptor. + When both interceptors are used, this `post_delete_vpc_flow_logs_config_with_metadata` interceptor runs after the + `post_delete_vpc_flow_logs_config` interceptor. The (possibly modified) response returned by + `post_delete_vpc_flow_logs_config` will be passed to + `post_delete_vpc_flow_logs_config_with_metadata`. + """ + return response, metadata + + def pre_get_vpc_flow_logs_config( + self, + request: vpc_flow_logs.GetVpcFlowLogsConfigRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.GetVpcFlowLogsConfigRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for get_vpc_flow_logs_config + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_get_vpc_flow_logs_config( + self, response: vpc_flow_logs_config.VpcFlowLogsConfig + ) -> vpc_flow_logs_config.VpcFlowLogsConfig: + """Post-rpc interceptor for get_vpc_flow_logs_config + + DEPRECATED. Please use the `post_get_vpc_flow_logs_config_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. This `post_get_vpc_flow_logs_config` interceptor runs + before the `post_get_vpc_flow_logs_config_with_metadata` interceptor. + """ + return response + + def post_get_vpc_flow_logs_config_with_metadata( + self, + response: vpc_flow_logs_config.VpcFlowLogsConfig, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs_config.VpcFlowLogsConfig, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for get_vpc_flow_logs_config + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the OrganizationVpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_get_vpc_flow_logs_config_with_metadata` + interceptor in new development instead of the `post_get_vpc_flow_logs_config` interceptor. + When both interceptors are used, this `post_get_vpc_flow_logs_config_with_metadata` interceptor runs after the + `post_get_vpc_flow_logs_config` interceptor. The (possibly modified) response returned by + `post_get_vpc_flow_logs_config` will be passed to + `post_get_vpc_flow_logs_config_with_metadata`. + """ + return response, metadata + + def pre_list_vpc_flow_logs_configs( + self, + request: vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for list_vpc_flow_logs_configs + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_list_vpc_flow_logs_configs( + self, response: vpc_flow_logs.ListVpcFlowLogsConfigsResponse + ) -> vpc_flow_logs.ListVpcFlowLogsConfigsResponse: + """Post-rpc interceptor for list_vpc_flow_logs_configs + + DEPRECATED. Please use the `post_list_vpc_flow_logs_configs_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. This `post_list_vpc_flow_logs_configs` interceptor runs + before the `post_list_vpc_flow_logs_configs_with_metadata` interceptor. + """ + return response + + def post_list_vpc_flow_logs_configs_with_metadata( + self, + response: vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for list_vpc_flow_logs_configs + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the OrganizationVpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_list_vpc_flow_logs_configs_with_metadata` + interceptor in new development instead of the `post_list_vpc_flow_logs_configs` interceptor. + When both interceptors are used, this `post_list_vpc_flow_logs_configs_with_metadata` interceptor runs after the + `post_list_vpc_flow_logs_configs` interceptor. The (possibly modified) response returned by + `post_list_vpc_flow_logs_configs` will be passed to + `post_list_vpc_flow_logs_configs_with_metadata`. + """ + return response, metadata + + def pre_update_vpc_flow_logs_config( + self, + request: vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for update_vpc_flow_logs_config + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_update_vpc_flow_logs_config( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for update_vpc_flow_logs_config + + DEPRECATED. Please use the `post_update_vpc_flow_logs_config_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. This `post_update_vpc_flow_logs_config` interceptor runs + before the `post_update_vpc_flow_logs_config_with_metadata` interceptor. + """ + return response + + def post_update_vpc_flow_logs_config_with_metadata( + self, + response: operations_pb2.Operation, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[operations_pb2.Operation, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for update_vpc_flow_logs_config + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the OrganizationVpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_update_vpc_flow_logs_config_with_metadata` + interceptor in new development instead of the `post_update_vpc_flow_logs_config` interceptor. + When both interceptors are used, this `post_update_vpc_flow_logs_config_with_metadata` interceptor runs after the + `post_update_vpc_flow_logs_config` interceptor. The (possibly modified) response returned by + `post_update_vpc_flow_logs_config` will be passed to + `post_update_vpc_flow_logs_config_with_metadata`. + """ + return response, metadata + + def pre_get_location( + self, + request: locations_pb2.GetLocationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + locations_pb2.GetLocationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_location + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_get_location( + self, response: locations_pb2.Location + ) -> locations_pb2.Location: + """Post-rpc interceptor for get_location + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_list_locations( + self, + request: locations_pb2.ListLocationsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + locations_pb2.ListLocationsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for list_locations + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_list_locations( + self, response: locations_pb2.ListLocationsResponse + ) -> locations_pb2.ListLocationsResponse: + """Post-rpc interceptor for list_locations + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_get_iam_policy( + self, + request: iam_policy_pb2.GetIamPolicyRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.GetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_iam_policy + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_get_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy: + """Post-rpc interceptor for get_iam_policy + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_set_iam_policy( + self, + request: iam_policy_pb2.SetIamPolicyRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.SetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for set_iam_policy + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_set_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy: + """Post-rpc interceptor for set_iam_policy + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_test_iam_permissions( + self, + request: iam_policy_pb2.TestIamPermissionsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.TestIamPermissionsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for test_iam_permissions + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_test_iam_permissions( + self, response: iam_policy_pb2.TestIamPermissionsResponse + ) -> iam_policy_pb2.TestIamPermissionsResponse: + """Post-rpc interceptor for test_iam_permissions + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_cancel_operation( + self, + request: operations_pb2.CancelOperationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.CancelOperationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for cancel_operation + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_cancel_operation(self, response: None) -> None: + """Post-rpc interceptor for cancel_operation + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_delete_operation( + self, + request: operations_pb2.DeleteOperationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.DeleteOperationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for delete_operation + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_delete_operation(self, response: None) -> None: + """Post-rpc interceptor for delete_operation + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_get_operation( + self, + request: operations_pb2.GetOperationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.GetOperationRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_operation + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_get_operation( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for get_operation + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + def pre_list_operations( + self, + request: operations_pb2.ListOperationsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + operations_pb2.ListOperationsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for list_operations + + Override in a subclass to manipulate the request or metadata + before they are sent to the OrganizationVpcFlowLogsService server. + """ + return request, metadata + + def post_list_operations( + self, response: operations_pb2.ListOperationsResponse + ) -> operations_pb2.ListOperationsResponse: + """Post-rpc interceptor for list_operations + + Override in a subclass to manipulate the response + after it is returned by the OrganizationVpcFlowLogsService server but before + it is returned to user code. + """ + return response + + +@dataclasses.dataclass +class OrganizationVpcFlowLogsServiceRestStub: + _session: AuthorizedSession + _host: str + _interceptor: OrganizationVpcFlowLogsServiceRestInterceptor + + +class OrganizationVpcFlowLogsServiceRestTransport( + _BaseOrganizationVpcFlowLogsServiceRestTransport +): + """REST backend synchronous transport for OrganizationVpcFlowLogsService. + + The VPC Flow Logs organization service in the Google Cloud + Network Management API provides organization level + configurations that generate Flow Logs. The service and the + configuration resources created using this service are global. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends JSON representations of protocol buffers over HTTP/1.1 + """ + + def __init__( + self, + *, + host: str = "networkmanagement.googleapis.com", + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + url_scheme: str = "https", + interceptor: Optional[OrganizationVpcFlowLogsServiceRestInterceptor] = None, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to (default: 'networkmanagement.googleapis.com'). + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + + credentials_file (Optional[str]): Deprecated. A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if ``channel`` is provided. This argument will be + removed in the next major version of this library. + scopes (Optional(Sequence[str])): A list of scopes. This argument is + ignored if ``channel`` is provided. + client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client + certificate to configure mutual TLS HTTP channel. It is ignored + if ``channel`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you are developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + url_scheme: the protocol scheme for the API endpoint. Normally + "https", but for testing or local servers, + "http" can be specified. + """ + # Run the base constructor + # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc. + # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the + # credentials object + super().__init__( + host=host, + credentials=credentials, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + url_scheme=url_scheme, + api_audience=api_audience, + ) + self._session = AuthorizedSession( + self._credentials, default_host=self.DEFAULT_HOST + ) + self._operations_client: Optional[operations_v1.AbstractOperationsClient] = None + if client_cert_source_for_mtls: + self._session.configure_mtls_channel(client_cert_source_for_mtls) + self._interceptor = ( + interceptor or OrganizationVpcFlowLogsServiceRestInterceptor() + ) + self._prep_wrapped_messages(client_info) + + @property + def operations_client(self) -> operations_v1.AbstractOperationsClient: + """Create the client designed to process long-running operations. + + This property caches on the instance; repeated calls return the same + client. + """ + # Only create a new client if we do not already have one. + if self._operations_client is None: + http_options: Dict[str, List[Dict[str, str]]] = { + "google.longrunning.Operations.CancelOperation": [ + { + "method": "post", + "uri": "/v1/{name=projects/*/locations/global/operations/*}:cancel", + "body": "*", + }, + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, + ], + "google.longrunning.Operations.DeleteOperation": [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/global/operations/*}", + }, + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, + ], + "google.longrunning.Operations.GetOperation": [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/global/operations/*}", + }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, + ], + "google.longrunning.Operations.ListOperations": [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/global}/operations", + }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, + ], + } + + rest_transport = operations_v1.OperationsRestTransport( + host=self._host, + # use the credentials which are saved + credentials=self._credentials, + scopes=self._scopes, + http_options=http_options, + path_prefix="v1", + ) + + self._operations_client = operations_v1.AbstractOperationsClient( + transport=rest_transport + ) + + # Return the client from cache. + return self._operations_client + + class _CreateVpcFlowLogsConfig( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCreateVpcFlowLogsConfig, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash( + "OrganizationVpcFlowLogsServiceRestTransport.CreateVpcFlowLogsConfig" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Call the create vpc flow logs + config method over HTTP. + + Args: + request (~.vpc_flow_logs.CreateVpcFlowLogsConfigRequest): + The request object. Request for the ``CreateVpcFlowLogsConfig`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCreateVpcFlowLogsConfig._get_http_options() + ) + + request, metadata = self._interceptor.pre_create_vpc_flow_logs_config( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCreateVpcFlowLogsConfig._get_transcoded_request( + http_options, request + ) + + body = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCreateVpcFlowLogsConfig._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCreateVpcFlowLogsConfig._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.CreateVpcFlowLogsConfig", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "CreateVpcFlowLogsConfig", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._CreateVpcFlowLogsConfig._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # 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 = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_create_vpc_flow_logs_config(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_create_vpc_flow_logs_config_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.create_vpc_flow_logs_config", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "CreateVpcFlowLogsConfig", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _DeleteVpcFlowLogsConfig( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteVpcFlowLogsConfig, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash( + "OrganizationVpcFlowLogsServiceRestTransport.DeleteVpcFlowLogsConfig" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Call the delete vpc flow logs + config method over HTTP. + + Args: + request (~.vpc_flow_logs.DeleteVpcFlowLogsConfigRequest): + The request object. Request for the ``DeleteVpcFlowLogsConfig`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteVpcFlowLogsConfig._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_vpc_flow_logs_config( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteVpcFlowLogsConfig._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteVpcFlowLogsConfig._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.DeleteVpcFlowLogsConfig", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "DeleteVpcFlowLogsConfig", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._DeleteVpcFlowLogsConfig._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_delete_vpc_flow_logs_config(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_delete_vpc_flow_logs_config_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.delete_vpc_flow_logs_config", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "DeleteVpcFlowLogsConfig", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetVpcFlowLogsConfig( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetVpcFlowLogsConfig, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash( + "OrganizationVpcFlowLogsServiceRestTransport.GetVpcFlowLogsConfig" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: vpc_flow_logs.GetVpcFlowLogsConfigRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> vpc_flow_logs_config.VpcFlowLogsConfig: + r"""Call the get vpc flow logs config method over HTTP. + + Args: + request (~.vpc_flow_logs.GetVpcFlowLogsConfigRequest): + The request object. Request for the ``GetVpcFlowLogsConfig`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.vpc_flow_logs_config.VpcFlowLogsConfig: + A configuration to generate VPC Flow + Logs. + + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetVpcFlowLogsConfig._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_vpc_flow_logs_config( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetVpcFlowLogsConfig._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetVpcFlowLogsConfig._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.GetVpcFlowLogsConfig", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetVpcFlowLogsConfig", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._GetVpcFlowLogsConfig._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = vpc_flow_logs_config.VpcFlowLogsConfig() + pb_resp = vpc_flow_logs_config.VpcFlowLogsConfig.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_get_vpc_flow_logs_config(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_get_vpc_flow_logs_config_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = vpc_flow_logs_config.VpcFlowLogsConfig.to_json( + response + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.get_vpc_flow_logs_config", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetVpcFlowLogsConfig", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ListVpcFlowLogsConfigs( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListVpcFlowLogsConfigs, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash( + "OrganizationVpcFlowLogsServiceRestTransport.ListVpcFlowLogsConfigs" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> vpc_flow_logs.ListVpcFlowLogsConfigsResponse: + r"""Call the list vpc flow logs + configs method over HTTP. + + Args: + request (~.vpc_flow_logs.ListVpcFlowLogsConfigsRequest): + The request object. Request for the ``ListVpcFlowLogsConfigs`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.vpc_flow_logs.ListVpcFlowLogsConfigsResponse: + Response for the ``ListVpcFlowLogsConfigs`` method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListVpcFlowLogsConfigs._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_vpc_flow_logs_configs( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListVpcFlowLogsConfigs._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListVpcFlowLogsConfigs._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.ListVpcFlowLogsConfigs", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "ListVpcFlowLogsConfigs", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._ListVpcFlowLogsConfigs._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + pb_resp = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_vpc_flow_logs_configs(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_list_vpc_flow_logs_configs_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse.to_json(response) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.list_vpc_flow_logs_configs", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "ListVpcFlowLogsConfigs", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _UpdateVpcFlowLogsConfig( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash( + "OrganizationVpcFlowLogsServiceRestTransport.UpdateVpcFlowLogsConfig" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Call the update vpc flow logs + config method over HTTP. + + Args: + request (~.vpc_flow_logs.UpdateVpcFlowLogsConfigRequest): + The request object. Request for the ``UpdateVpcFlowLogsConfig`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig._get_http_options() + ) + + request, metadata = self._interceptor.pre_update_vpc_flow_logs_config( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig._get_transcoded_request( + http_options, request + ) + + body = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.UpdateVpcFlowLogsConfig", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "UpdateVpcFlowLogsConfig", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._UpdateVpcFlowLogsConfig._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # 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 = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_update_vpc_flow_logs_config(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_update_vpc_flow_logs_config_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.update_vpc_flow_logs_config", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "UpdateVpcFlowLogsConfig", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + @property + def create_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.CreateVpcFlowLogsConfigRequest], operations_pb2.Operation + ]: + # 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._CreateVpcFlowLogsConfig(self._session, self._host, self._interceptor) # type: ignore + + @property + def delete_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.DeleteVpcFlowLogsConfigRequest], operations_pb2.Operation + ]: + # 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._DeleteVpcFlowLogsConfig(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.GetVpcFlowLogsConfigRequest], + vpc_flow_logs_config.VpcFlowLogsConfig, + ]: + # 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._GetVpcFlowLogsConfig(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ListVpcFlowLogsConfigsRequest], + vpc_flow_logs.ListVpcFlowLogsConfigsResponse, + ]: + # 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._ListVpcFlowLogsConfigs(self._session, self._host, self._interceptor) # type: ignore + + @property + def update_vpc_flow_logs_config( + self, + ) -> Callable[ + [vpc_flow_logs.UpdateVpcFlowLogsConfigRequest], operations_pb2.Operation + ]: + # 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._UpdateVpcFlowLogsConfig(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_location(self): + return self._GetLocation(self._session, self._host, self._interceptor) # type: ignore + + class _GetLocation( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetLocation, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.GetLocation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: locations_pb2.GetLocationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.Location: + r"""Call the get location method over HTTP. + + Args: + request (locations_pb2.GetLocationRequest): + The request object for GetLocation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + locations_pb2.Location: Response from GetLocation method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetLocation._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_location(request, metadata) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetLocation._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetLocation._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.GetLocation", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetLocation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + OrganizationVpcFlowLogsServiceRestTransport._GetLocation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = locations_pb2.Location() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_get_location(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.GetLocation", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetLocation", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def list_locations(self): + return self._ListLocations(self._session, self._host, self._interceptor) # type: ignore + + class _ListLocations( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListLocations, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.ListLocations") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: locations_pb2.ListLocationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> locations_pb2.ListLocationsResponse: + r"""Call the list locations method over HTTP. + + Args: + request (locations_pb2.ListLocationsRequest): + The request object for ListLocations 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + locations_pb2.ListLocationsResponse: Response from ListLocations method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListLocations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_locations(request, metadata) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListLocations._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListLocations._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.ListLocations", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "ListLocations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._ListLocations._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = locations_pb2.ListLocationsResponse() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_list_locations(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.ListLocations", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "ListLocations", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def get_iam_policy(self): + return self._GetIamPolicy(self._session, self._host, self._interceptor) # type: ignore + + class _GetIamPolicy( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetIamPolicy, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.GetIamPolicy") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: iam_policy_pb2.GetIamPolicyRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Call the get iam policy method over HTTP. + + Args: + request (iam_policy_pb2.GetIamPolicyRequest): + The request object for GetIamPolicy 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + policy_pb2.Policy: Response from GetIamPolicy method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetIamPolicy._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_iam_policy(request, metadata) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetIamPolicy._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetIamPolicy._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.GetIamPolicy", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetIamPolicy", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + OrganizationVpcFlowLogsServiceRestTransport._GetIamPolicy._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = policy_pb2.Policy() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_get_iam_policy(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.GetIamPolicy", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetIamPolicy", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def set_iam_policy(self): + return self._SetIamPolicy(self._session, self._host, self._interceptor) # type: ignore + + class _SetIamPolicy( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseSetIamPolicy, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.SetIamPolicy") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: iam_policy_pb2.SetIamPolicyRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Call the set iam policy method over HTTP. + + Args: + request (iam_policy_pb2.SetIamPolicyRequest): + The request object for SetIamPolicy 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + policy_pb2.Policy: Response from SetIamPolicy method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseSetIamPolicy._get_http_options() + ) + + request, metadata = self._interceptor.pre_set_iam_policy(request, metadata) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseSetIamPolicy._get_transcoded_request( + http_options, request + ) + + body = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseSetIamPolicy._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseSetIamPolicy._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.SetIamPolicy", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "SetIamPolicy", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + OrganizationVpcFlowLogsServiceRestTransport._SetIamPolicy._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = policy_pb2.Policy() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_set_iam_policy(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.SetIamPolicy", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "SetIamPolicy", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def test_iam_permissions(self): + return self._TestIamPermissions(self._session, self._host, self._interceptor) # type: ignore + + class _TestIamPermissions( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseTestIamPermissions, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash( + "OrganizationVpcFlowLogsServiceRestTransport.TestIamPermissions" + ) + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: iam_policy_pb2.TestIamPermissionsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> iam_policy_pb2.TestIamPermissionsResponse: + r"""Call the test iam permissions method over HTTP. + + Args: + request (iam_policy_pb2.TestIamPermissionsRequest): + The request object for TestIamPermissions 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + iam_policy_pb2.TestIamPermissionsResponse: Response from TestIamPermissions method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseTestIamPermissions._get_http_options() + ) + + request, metadata = self._interceptor.pre_test_iam_permissions( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseTestIamPermissions._get_transcoded_request( + http_options, request + ) + + body = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseTestIamPermissions._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseTestIamPermissions._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.TestIamPermissions", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "TestIamPermissions", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._TestIamPermissions._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = iam_policy_pb2.TestIamPermissionsResponse() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_test_iam_permissions(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.TestIamPermissions", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "TestIamPermissions", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def cancel_operation(self): + return self._CancelOperation(self._session, self._host, self._interceptor) # type: ignore + + class _CancelOperation( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCancelOperation, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.CancelOperation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + return response + + def __call__( + self, + request: operations_pb2.CancelOperationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Call the cancel operation method over HTTP. + + Args: + request (operations_pb2.CancelOperationRequest): + The request object for CancelOperation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCancelOperation._get_http_options() + ) + + request, metadata = self._interceptor.pre_cancel_operation( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCancelOperation._get_transcoded_request( + http_options, request + ) + + body = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCancelOperation._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCancelOperation._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.CancelOperation", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "CancelOperation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._CancelOperation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # 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 self._interceptor.post_cancel_operation(None) + + @property + def delete_operation(self): + return self._DeleteOperation(self._session, self._host, self._interceptor) # type: ignore + + class _DeleteOperation( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteOperation, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.DeleteOperation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: operations_pb2.DeleteOperationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Call the delete operation method over HTTP. + + Args: + request (operations_pb2.DeleteOperationRequest): + The request object for DeleteOperation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteOperation._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_operation( + request, metadata + ) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteOperation._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteOperation._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.DeleteOperation", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "DeleteOperation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._DeleteOperation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 self._interceptor.post_delete_operation(None) + + @property + def get_operation(self): + return self._GetOperation(self._session, self._host, self._interceptor) # type: ignore + + class _GetOperation( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetOperation, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.GetOperation") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: operations_pb2.GetOperationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Call the get operation method over HTTP. + + Args: + request (operations_pb2.GetOperationRequest): + The request object for GetOperation 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + operations_pb2.Operation: Response from GetOperation method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetOperation._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_operation(request, metadata) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetOperation._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetOperation._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.GetOperation", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetOperation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + OrganizationVpcFlowLogsServiceRestTransport._GetOperation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = operations_pb2.Operation() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_get_operation(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.GetOperation", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "GetOperation", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def list_operations(self): + return self._ListOperations(self._session, self._host, self._interceptor) # type: ignore + + class _ListOperations( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListOperations, + OrganizationVpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("OrganizationVpcFlowLogsServiceRestTransport.ListOperations") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: operations_pb2.ListOperationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.ListOperationsResponse: + r"""Call the list operations method over HTTP. + + Args: + request (operations_pb2.ListOperationsRequest): + The request object for ListOperations 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + operations_pb2.ListOperationsResponse: Response from ListOperations method. + """ + + http_options = ( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListOperations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_operations(request, metadata) + transcoded_request = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListOperations._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListOperations._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceClient.ListOperations", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "ListOperations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = OrganizationVpcFlowLogsServiceRestTransport._ListOperations._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + content = response.content.decode("utf-8") + resp = operations_pb2.ListOperationsResponse() + resp = json_format.Parse(content, resp) + resp = self._interceptor.post_list_operations(resp) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.OrganizationVpcFlowLogsServiceAsyncClient.ListOperations", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "rpcName": "ListOperations", + "httpResponse": http_response, + "metadata": http_response["headers"], + }, + ) + return resp + + @property + def kind(self) -> str: + return "rest" + + def close(self): + self._session.close() + + +__all__ = ("OrganizationVpcFlowLogsServiceRestTransport",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/rest_base.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/rest_base.py new file mode 100644 index 000000000000..3ebe0ab2362a --- /dev/null +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/organization_vpc_flow_logs_service/transports/rest_base.py @@ -0,0 +1,624 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import json # type: ignore +import re +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union + +from google.api_core import gapic_v1, path_template +from google.cloud.location import locations_pb2 # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.protobuf import json_format + +from google.cloud.network_management_v1.types import vpc_flow_logs, vpc_flow_logs_config + +from .base import DEFAULT_CLIENT_INFO, OrganizationVpcFlowLogsServiceTransport + + +class _BaseOrganizationVpcFlowLogsServiceRestTransport( + OrganizationVpcFlowLogsServiceTransport +): + """Base REST backend transport for OrganizationVpcFlowLogsService. + + Note: This class is not meant to be used directly. Use its sync and + async sub-classes instead. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends JSON representations of protocol buffers over HTTP/1.1 + """ + + def __init__( + self, + *, + host: str = "networkmanagement.googleapis.com", + credentials: Optional[Any] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + url_scheme: str = "https", + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + Args: + host (Optional[str]): + The hostname to connect to (default: 'networkmanagement.googleapis.com'). + credentials (Optional[Any]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you are developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + url_scheme: the protocol scheme for the API endpoint. Normally + "https", but for testing or local servers, + "http" can be specified. + """ + # Run the base constructor + maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host) + if maybe_url_match is None: + raise ValueError( + f"Unexpected hostname structure: {host}" + ) # pragma: NO COVER + + url_match_items = maybe_url_match.groupdict() + + host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host + + super().__init__( + host=host, + credentials=credentials, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + + class _BaseCreateVpcFlowLogsConfig: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "vpcFlowLogsConfigId": "", + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{parent=organizations/*/locations/*}/vpcFlowLogsConfigs", + "body": "vpc_flow_logs_config", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], use_integers_for_enums=True + ) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseCreateVpcFlowLogsConfig._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseDeleteVpcFlowLogsConfig: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/vpcFlowLogsConfigs/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseDeleteVpcFlowLogsConfig._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseGetVpcFlowLogsConfig: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/vpcFlowLogsConfigs/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.GetVpcFlowLogsConfigRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseGetVpcFlowLogsConfig._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseListVpcFlowLogsConfigs: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=organizations/*/locations/*}/vpcFlowLogsConfigs", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseListVpcFlowLogsConfigs._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseUpdateVpcFlowLogsConfig: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "updateMask": {}, + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "patch", + "uri": "/v1/{vpc_flow_logs_config.name=organizations/*/locations/*/vpcFlowLogsConfigs/*}", + "body": "vpc_flow_logs_config", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], use_integers_for_enums=True + ) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseOrganizationVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseGetLocation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*}", + }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseListLocations: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*}/locations", + }, + { + "method": "get", + "uri": "/v1/{name=organizations/*}/locations", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseGetIamPolicy: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{resource=projects/*/locations/global/connectivityTests/*}:getIamPolicy", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseSetIamPolicy: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{resource=projects/*/locations/global/connectivityTests/*}:setIamPolicy", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + body = json.dumps(transcoded_request["body"]) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseTestIamPermissions: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{resource=projects/*/locations/global/connectivityTests/*}:testIamPermissions", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + body = json.dumps(transcoded_request["body"]) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseCancelOperation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{name=projects/*/locations/global/operations/*}:cancel", + "body": "*", + }, + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_request_body_json(transcoded_request): + body = json.dumps(transcoded_request["body"]) + return body + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseDeleteOperation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/global/operations/*}", + }, + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseGetOperation: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/global/operations/*}", + }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + class _BaseListOperations: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/global}/operations", + }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + request_kwargs = json_format.MessageToDict(request) + transcoded_request = path_template.transcode(http_options, **request_kwargs) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads(json.dumps(transcoded_request["query_params"])) + return query_params + + +__all__ = ("_BaseOrganizationVpcFlowLogsServiceRestTransport",) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest.py index 592b246da15c..75404206e40d 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest.py @@ -760,24 +760,41 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient: "uri": "/v1/{name=projects/*/locations/global/operations/*}:cancel", "body": "*", }, + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, ], "google.longrunning.Operations.DeleteOperation": [ { "method": "delete", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ], "google.longrunning.Operations.GetOperation": [ { "method": "get", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ], "google.longrunning.Operations.ListOperations": [ { "method": "get", "uri": "/v1/{name=projects/*/locations/global}/operations", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, ], } diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest_base.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest_base.py index 1eae18d749e0..1ea3326be1c8 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest_base.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/reachability_service/transports/rest_base.py @@ -418,6 +418,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*/locations/*}", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}", + }, ] return http_options @@ -443,6 +447,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*}/locations", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*}/locations", + }, ] return http_options @@ -556,6 +564,11 @@ def _get_http_options(): "uri": "/v1/{name=projects/*/locations/global/operations/*}:cancel", "body": "*", }, + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, ] return http_options @@ -586,6 +599,10 @@ def _get_http_options(): "method": "delete", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ] return http_options @@ -611,6 +628,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ] return http_options @@ -636,6 +657,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*/locations/global}/operations", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, ] return http_options diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/async_client.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/async_client.py index 6ea8cf690852..61e20f1ae8bf 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/async_client.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/async_client.py @@ -357,8 +357,14 @@ async def sample_list_vpc_flow_logs_configs(): request (Optional[Union[google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest, dict]]): The request object. Request for the ``ListVpcFlowLogsConfigs`` method. parent (:class:`str`): - Required. The parent resource of the VpcFlowLogsConfig: - ``projects/{project_id}/locations/global`` + Required. The parent resource of the VpcFlowLogsConfig, + in one of the following formats: + + - For project-level resourcs: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this @@ -482,9 +488,14 @@ async def sample_get_vpc_flow_logs_config(): request (Optional[Union[google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest, dict]]): The request object. Request for the ``GetVpcFlowLogsConfig`` method. name (:class:`str`): - Required. ``VpcFlowLogsConfig`` resource name using the - form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config}`` + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this @@ -571,11 +582,11 @@ async def create_vpc_flow_logs_config( exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Creating a configuration with state=DISABLED will fail - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - creating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -600,7 +611,7 @@ async def sample_create_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.CreateVpcFlowLogsConfigRequest( parent="parent_value", @@ -622,9 +633,14 @@ async def sample_create_vpc_flow_logs_config(): request (Optional[Union[google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest, dict]]): The request object. Request for the ``CreateVpcFlowLogsConfig`` method. parent (:class:`str`): - Required. The parent resource of the VPC Flow Logs - configuration to create: - ``projects/{project_id}/locations/global`` + Required. The parent resource of the VpcFlowLogsConfig + to create, in one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this @@ -735,11 +751,11 @@ async def update_vpc_flow_logs_config( with the exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Updating a configuration with state=DISABLED will fail. - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - updating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Updating a configuration with ``state=DISABLED`` will fail. + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -764,7 +780,7 @@ async def sample_update_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.UpdateVpcFlowLogsConfigRequest( vpc_flow_logs_config=vpc_flow_logs_config, @@ -791,9 +807,12 @@ async def sample_update_vpc_flow_logs_config(): on the ``request`` instance; if ``request`` is provided, this should not be set. update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): - Required. Mask of fields to update. - At least one path must be supplied in - this field. + Required. Mask of fields to update. At least one path + must be supplied in this field. For example, to change + the state of the configuration to ENABLED, specify + ``update_mask`` = ``"state"``, and the + ``vpc_flow_logs_config`` would be: + ``vpc_flow_logs_config = { name = "projects/my-project/locations/global/vpcFlowLogsConfigs/my-config" state = "ENABLED" }`` This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -923,9 +942,14 @@ async def sample_delete_vpc_flow_logs_config(): request (Optional[Union[google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest, dict]]): The request object. Request for the ``DeleteVpcFlowLogsConfig`` method. name (:class:`str`): - Required. ``VpcFlowLogsConfig`` resource name using the - form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config}`` + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For a project-level resource: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For an organization-level resource: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this @@ -1011,6 +1035,213 @@ async def sample_delete_vpc_flow_logs_config(): # Done; return the response. return response + async def query_org_vpc_flow_logs_configs( + self, + request: Optional[ + Union[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.QueryOrgVpcFlowLogsConfigsAsyncPager: + r"""QueryOrgVpcFlowLogsConfigs returns a list of all + organization-level VPC Flow Logs configurations + applicable to the specified project. + + .. 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 network_management_v1 + + async def sample_query_org_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.QueryOrgVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.query_org_vpc_flow_logs_configs(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsRequest, dict]]): + The request object. Request for the ``QueryOrgVpcFlowLogsConfigs`` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.QueryOrgVpcFlowLogsConfigsAsyncPager: + Response for the QueryVpcFlowLogsConfigs method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest): + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.query_org_vpc_flow_logs_configs + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.QueryOrgVpcFlowLogsConfigsAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def show_effective_flow_logs_configs( + self, + request: Optional[ + Union[vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ShowEffectiveFlowLogsConfigsAsyncPager: + r"""ShowEffectiveFlowLogsConfigs returns a list of all + VPC Flow Logs configurations applicable to a specified + resource. + + .. 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 network_management_v1 + + async def sample_show_effective_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.ShowEffectiveFlowLogsConfigsRequest( + parent="parent_value", + resource="resource_value", + ) + + # Make the request + page_result = client.show_effective_flow_logs_configs(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsRequest, dict]]): + The request object. Request for the ``ShowEffectiveFlowLogsConfigs`` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ShowEffectiveFlowLogsConfigsAsyncPager: + Response for the ShowEffectiveFlowLogsConfigs method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest): + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.show_effective_flow_logs_configs + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ShowEffectiveFlowLogsConfigsAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + async def list_operations( self, request: Optional[operations_pb2.ListOperationsRequest] = None, diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/client.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/client.py index 3ebba2142421..96805eff82c0 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/client.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/client.py @@ -777,8 +777,14 @@ def sample_list_vpc_flow_logs_configs(): request (Union[google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest, dict]): The request object. Request for the ``ListVpcFlowLogsConfigs`` method. parent (str): - Required. The parent resource of the VpcFlowLogsConfig: - ``projects/{project_id}/locations/global`` + Required. The parent resource of the VpcFlowLogsConfig, + in one of the following formats: + + - For project-level resourcs: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this @@ -901,9 +907,14 @@ def sample_get_vpc_flow_logs_config(): request (Union[google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest, dict]): The request object. Request for the ``GetVpcFlowLogsConfig`` method. name (str): - Required. ``VpcFlowLogsConfig`` resource name using the - form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config}`` + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this @@ -987,11 +998,11 @@ def create_vpc_flow_logs_config( exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Creating a configuration with state=DISABLED will fail - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - creating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -1016,7 +1027,7 @@ def sample_create_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.CreateVpcFlowLogsConfigRequest( parent="parent_value", @@ -1038,9 +1049,14 @@ def sample_create_vpc_flow_logs_config(): request (Union[google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest, dict]): The request object. Request for the ``CreateVpcFlowLogsConfig`` method. parent (str): - Required. The parent resource of the VPC Flow Logs - configuration to create: - ``projects/{project_id}/locations/global`` + Required. The parent resource of the VpcFlowLogsConfig + to create, in one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this @@ -1150,11 +1166,11 @@ def update_vpc_flow_logs_config( with the exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Updating a configuration with state=DISABLED will fail. - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - updating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Updating a configuration with ``state=DISABLED`` will fail. + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -1179,7 +1195,7 @@ def sample_update_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.UpdateVpcFlowLogsConfigRequest( vpc_flow_logs_config=vpc_flow_logs_config, @@ -1206,9 +1222,12 @@ def sample_update_vpc_flow_logs_config(): on the ``request`` instance; if ``request`` is provided, this should not be set. update_mask (google.protobuf.field_mask_pb2.FieldMask): - Required. Mask of fields to update. - At least one path must be supplied in - this field. + Required. Mask of fields to update. At least one path + must be supplied in this field. For example, to change + the state of the configuration to ENABLED, specify + ``update_mask`` = ``"state"``, and the + ``vpc_flow_logs_config`` would be: + ``vpc_flow_logs_config = { name = "projects/my-project/locations/global/vpcFlowLogsConfigs/my-config" state = "ENABLED" }`` This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -1337,9 +1356,14 @@ def sample_delete_vpc_flow_logs_config(): request (Union[google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest, dict]): The request object. Request for the ``DeleteVpcFlowLogsConfig`` method. name (str): - Required. ``VpcFlowLogsConfig`` resource name using the - form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config}`` + Required. The resource name of the VpcFlowLogsConfig, in + one of the following formats: + + - For a project-level resource: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For an organization-level resource: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this @@ -1424,6 +1448,213 @@ def sample_delete_vpc_flow_logs_config(): # Done; return the response. return response + def query_org_vpc_flow_logs_configs( + self, + request: Optional[ + Union[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.QueryOrgVpcFlowLogsConfigsPager: + r"""QueryOrgVpcFlowLogsConfigs returns a list of all + organization-level VPC Flow Logs configurations + applicable to the specified project. + + .. 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 network_management_v1 + + def sample_query_org_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.QueryOrgVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.query_org_vpc_flow_logs_configs(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsRequest, dict]): + The request object. Request for the ``QueryOrgVpcFlowLogsConfigs`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.QueryOrgVpcFlowLogsConfigsPager: + Response for the QueryVpcFlowLogsConfigs method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest): + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.query_org_vpc_flow_logs_configs + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.QueryOrgVpcFlowLogsConfigsPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def show_effective_flow_logs_configs( + self, + request: Optional[ + Union[vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> pagers.ShowEffectiveFlowLogsConfigsPager: + r"""ShowEffectiveFlowLogsConfigs returns a list of all + VPC Flow Logs configurations applicable to a specified + resource. + + .. 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 network_management_v1 + + def sample_show_effective_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.ShowEffectiveFlowLogsConfigsRequest( + parent="parent_value", + resource="resource_value", + ) + + # Make the request + page_result = client.show_effective_flow_logs_configs(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsRequest, dict]): + The request object. Request for the ``ShowEffectiveFlowLogsConfigs`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ShowEffectiveFlowLogsConfigsPager: + Response for the ShowEffectiveFlowLogsConfigs method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest): + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.show_effective_flow_logs_configs + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ShowEffectiveFlowLogsConfigsPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + def __enter__(self) -> "VpcFlowLogsServiceClient": return self diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/pagers.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/pagers.py index 6502a505d0ce..d9a5c6117ec5 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/pagers.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/pagers.py @@ -197,3 +197,325 @@ async def async_generator(): def __repr__(self) -> str: return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class QueryOrgVpcFlowLogsConfigsPager: + """A pager for iterating through ``query_org_vpc_flow_logs_configs`` requests. + + This class thinly wraps an initial + :class:`google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``vpc_flow_logs_configs`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``QueryOrgVpcFlowLogsConfigs`` requests and continue to iterate + through the ``vpc_flow_logs_configs`` field on the + corresponding responses. + + All the usual :class:`google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsResponse` + 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[..., vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse], + request: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, + response: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsRequest): + The initial request object. + response (google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[vpc_flow_logs_config.VpcFlowLogsConfig]: + for page in self.pages: + yield from page.vpc_flow_logs_configs + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class QueryOrgVpcFlowLogsConfigsAsyncPager: + """A pager for iterating through ``query_org_vpc_flow_logs_configs`` requests. + + This class thinly wraps an initial + :class:`google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``vpc_flow_logs_configs`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``QueryOrgVpcFlowLogsConfigs`` requests and continue to iterate + through the ``vpc_flow_logs_configs`` field on the + corresponding responses. + + All the usual :class:`google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsResponse` + 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[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse] + ], + request: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, + response: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsRequest): + The initial request object. + response (google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__(self) -> AsyncIterator[vpc_flow_logs_config.VpcFlowLogsConfig]: + async def async_generator(): + async for page in self.pages: + for response in page.vpc_flow_logs_configs: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ShowEffectiveFlowLogsConfigsPager: + """A pager for iterating through ``show_effective_flow_logs_configs`` requests. + + This class thinly wraps an initial + :class:`google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``effective_flow_logs_configs`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ShowEffectiveFlowLogsConfigs`` requests and continue to iterate + through the ``effective_flow_logs_configs`` field on the + corresponding responses. + + All the usual :class:`google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsResponse` + 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[..., vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse], + request: vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, + response: vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsRequest): + The initial request object. + response (google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsResponse): + The initial response object. + 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method( + self._request, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __iter__(self) -> Iterator[vpc_flow_logs_config.EffectiveVpcFlowLogsConfig]: + for page in self.pages: + yield from page.effective_flow_logs_configs + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ShowEffectiveFlowLogsConfigsAsyncPager: + """A pager for iterating through ``show_effective_flow_logs_configs`` requests. + + This class thinly wraps an initial + :class:`google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``effective_flow_logs_configs`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ShowEffectiveFlowLogsConfigs`` requests and continue to iterate + through the ``effective_flow_logs_configs`` field on the + corresponding responses. + + All the usual :class:`google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsResponse` + 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[vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse] + ], + request: vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, + response: vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsRequest): + The initial request object. + response (google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsResponse): + The initial response object. + retry (google.api_core.retry.AsyncRetry): Designation of what errors, + if any, should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + self._method = method + self._request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest(request) + self._response = response + self._retry = retry + self._timeout = timeout + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages( + self, + ) -> AsyncIterator[vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse]: + 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, + retry=self._retry, + timeout=self._timeout, + metadata=self._metadata, + ) + yield self._response + + def __aiter__( + self, + ) -> AsyncIterator[vpc_flow_logs_config.EffectiveVpcFlowLogsConfig]: + async def async_generator(): + async for page in self.pages: + for response in page.effective_flow_logs_configs: + 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-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/base.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/base.py index 8ae5943ee186..46f7577ed551 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/base.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/base.py @@ -162,6 +162,16 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.query_org_vpc_flow_logs_configs: gapic_v1.method.wrap_method( + self.query_org_vpc_flow_logs_configs, + default_timeout=None, + client_info=client_info, + ), + self.show_effective_flow_logs_configs: gapic_v1.method.wrap_method( + self.show_effective_flow_logs_configs, + default_timeout=None, + client_info=client_info, + ), self.get_location: gapic_v1.method.wrap_method( self.get_location, default_timeout=None, @@ -274,6 +284,30 @@ def delete_vpc_flow_logs_config( ]: raise NotImplementedError() + @property + def query_org_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest], + Union[ + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + Awaitable[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse], + ], + ]: + raise NotImplementedError() + + @property + def show_effective_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest], + Union[ + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + Awaitable[vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse], + ], + ]: + raise NotImplementedError() + @property def list_operations( self, diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc.py index af660c5faed1..856909cdbe8e 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc.py @@ -417,11 +417,11 @@ def create_vpc_flow_logs_config( exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Creating a configuration with state=DISABLED will fail - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - creating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -461,11 +461,11 @@ def update_vpc_flow_logs_config( with the exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Updating a configuration with state=DISABLED will fail. - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - updating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Updating a configuration with ``state=DISABLED`` will fail. + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -523,6 +523,74 @@ def delete_vpc_flow_logs_config( ) return self._stubs["delete_vpc_flow_logs_config"] + @property + def query_org_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest], + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + ]: + r"""Return a callable for the query org vpc flow logs + configs method over gRPC. + + QueryOrgVpcFlowLogsConfigs returns a list of all + organization-level VPC Flow Logs configurations + applicable to the specified project. + + Returns: + Callable[[~.QueryOrgVpcFlowLogsConfigsRequest], + ~.QueryOrgVpcFlowLogsConfigsResponse]: + 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 "query_org_vpc_flow_logs_configs" not in self._stubs: + self._stubs[ + "query_org_vpc_flow_logs_configs" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.VpcFlowLogsService/QueryOrgVpcFlowLogsConfigs", + request_serializer=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest.serialize, + response_deserializer=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.deserialize, + ) + return self._stubs["query_org_vpc_flow_logs_configs"] + + @property + def show_effective_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest], + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + ]: + r"""Return a callable for the show effective flow logs + configs method over gRPC. + + ShowEffectiveFlowLogsConfigs returns a list of all + VPC Flow Logs configurations applicable to a specified + resource. + + Returns: + Callable[[~.ShowEffectiveFlowLogsConfigsRequest], + ~.ShowEffectiveFlowLogsConfigsResponse]: + 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 "show_effective_flow_logs_configs" not in self._stubs: + self._stubs[ + "show_effective_flow_logs_configs" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.VpcFlowLogsService/ShowEffectiveFlowLogsConfigs", + request_serializer=vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest.serialize, + response_deserializer=vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.deserialize, + ) + return self._stubs["show_effective_flow_logs_configs"] + def close(self): self._logged_channel.close() diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc_asyncio.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc_asyncio.py index ceeb63b4c39f..3f7070f95162 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc_asyncio.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/grpc_asyncio.py @@ -426,11 +426,11 @@ def create_vpc_flow_logs_config( exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Creating a configuration with state=DISABLED will fail - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - creating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Creating a configuration with ``state=DISABLED`` will fail + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - creating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -471,11 +471,11 @@ def update_vpc_flow_logs_config( with the exact same settings already exists (even if the ID is different), the creation fails. Notes: - 1. Updating a configuration with state=DISABLED will fail. - 2. The following fields are not considered as ``settings`` for - the purpose of the check mentioned above, therefore - - updating another configuration with the same fields but - different values for the following fields will fail as well: + 1. Updating a configuration with ``state=DISABLED`` will fail. + 2. The following fields are not considered as settings for the + purpose of the check mentioned above, therefore - updating + another configuration with the same fields but different + values for the following fields will fail as well: - name - create_time @@ -534,6 +534,74 @@ def delete_vpc_flow_logs_config( ) return self._stubs["delete_vpc_flow_logs_config"] + @property + def query_org_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest], + Awaitable[vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse], + ]: + r"""Return a callable for the query org vpc flow logs + configs method over gRPC. + + QueryOrgVpcFlowLogsConfigs returns a list of all + organization-level VPC Flow Logs configurations + applicable to the specified project. + + Returns: + Callable[[~.QueryOrgVpcFlowLogsConfigsRequest], + Awaitable[~.QueryOrgVpcFlowLogsConfigsResponse]]: + 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 "query_org_vpc_flow_logs_configs" not in self._stubs: + self._stubs[ + "query_org_vpc_flow_logs_configs" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.VpcFlowLogsService/QueryOrgVpcFlowLogsConfigs", + request_serializer=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest.serialize, + response_deserializer=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.deserialize, + ) + return self._stubs["query_org_vpc_flow_logs_configs"] + + @property + def show_effective_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest], + Awaitable[vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse], + ]: + r"""Return a callable for the show effective flow logs + configs method over gRPC. + + ShowEffectiveFlowLogsConfigs returns a list of all + VPC Flow Logs configurations applicable to a specified + resource. + + Returns: + Callable[[~.ShowEffectiveFlowLogsConfigsRequest], + Awaitable[~.ShowEffectiveFlowLogsConfigsResponse]]: + 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 "show_effective_flow_logs_configs" not in self._stubs: + self._stubs[ + "show_effective_flow_logs_configs" + ] = self._logged_channel.unary_unary( + "/google.cloud.networkmanagement.v1.VpcFlowLogsService/ShowEffectiveFlowLogsConfigs", + request_serializer=vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest.serialize, + response_deserializer=vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.deserialize, + ) + return self._stubs["show_effective_flow_logs_configs"] + def _prep_wrapped_messages(self, client_info): """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" self._wrapped_methods = { @@ -562,6 +630,16 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.query_org_vpc_flow_logs_configs: self._wrap_method( + self.query_org_vpc_flow_logs_configs, + default_timeout=None, + client_info=client_info, + ), + self.show_effective_flow_logs_configs: self._wrap_method( + self.show_effective_flow_logs_configs, + default_timeout=None, + client_info=client_info, + ), self.get_location: self._wrap_method( self.get_location, default_timeout=None, diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest.py index 9395f76f55eb..140d14e2c7e3 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest.py @@ -108,6 +108,22 @@ def post_list_vpc_flow_logs_configs(self, response): logging.log(f"Received response: {response}") return response + def pre_query_org_vpc_flow_logs_configs(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_query_org_vpc_flow_logs_configs(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_show_effective_flow_logs_configs(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_show_effective_flow_logs_configs(self, response): + logging.log(f"Received response: {response}") + return response + def pre_update_vpc_flow_logs_config(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -323,6 +339,110 @@ def post_list_vpc_flow_logs_configs_with_metadata( """ return response, metadata + def pre_query_org_vpc_flow_logs_configs( + self, + request: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for query_org_vpc_flow_logs_configs + + Override in a subclass to manipulate the request or metadata + before they are sent to the VpcFlowLogsService server. + """ + return request, metadata + + def post_query_org_vpc_flow_logs_configs( + self, response: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse + ) -> vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse: + """Post-rpc interceptor for query_org_vpc_flow_logs_configs + + DEPRECATED. Please use the `post_query_org_vpc_flow_logs_configs_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the VpcFlowLogsService server but before + it is returned to user code. This `post_query_org_vpc_flow_logs_configs` interceptor runs + before the `post_query_org_vpc_flow_logs_configs_with_metadata` interceptor. + """ + return response + + def post_query_org_vpc_flow_logs_configs_with_metadata( + self, + response: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for query_org_vpc_flow_logs_configs + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the VpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_query_org_vpc_flow_logs_configs_with_metadata` + interceptor in new development instead of the `post_query_org_vpc_flow_logs_configs` interceptor. + When both interceptors are used, this `post_query_org_vpc_flow_logs_configs_with_metadata` interceptor runs after the + `post_query_org_vpc_flow_logs_configs` interceptor. The (possibly modified) response returned by + `post_query_org_vpc_flow_logs_configs` will be passed to + `post_query_org_vpc_flow_logs_configs_with_metadata`. + """ + return response, metadata + + def pre_show_effective_flow_logs_configs( + self, + request: vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for show_effective_flow_logs_configs + + Override in a subclass to manipulate the request or metadata + before they are sent to the VpcFlowLogsService server. + """ + return request, metadata + + def post_show_effective_flow_logs_configs( + self, response: vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse + ) -> vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse: + """Post-rpc interceptor for show_effective_flow_logs_configs + + DEPRECATED. Please use the `post_show_effective_flow_logs_configs_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the VpcFlowLogsService server but before + it is returned to user code. This `post_show_effective_flow_logs_configs` interceptor runs + before the `post_show_effective_flow_logs_configs_with_metadata` interceptor. + """ + return response + + def post_show_effective_flow_logs_configs_with_metadata( + self, + response: vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for show_effective_flow_logs_configs + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the VpcFlowLogsService server but before it is returned to user code. + + We recommend only using this `post_show_effective_flow_logs_configs_with_metadata` + interceptor in new development instead of the `post_show_effective_flow_logs_configs` interceptor. + When both interceptors are used, this `post_show_effective_flow_logs_configs_with_metadata` interceptor runs after the + `post_show_effective_flow_logs_configs` interceptor. The (possibly modified) response returned by + `post_show_effective_flow_logs_configs` will be passed to + `post_show_effective_flow_logs_configs_with_metadata`. + """ + return response, metadata + def pre_update_vpc_flow_logs_config( self, request: vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, @@ -698,24 +818,41 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient: "uri": "/v1/{name=projects/*/locations/global/operations/*}:cancel", "body": "*", }, + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, ], "google.longrunning.Operations.DeleteOperation": [ { "method": "delete", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ], "google.longrunning.Operations.GetOperation": [ { "method": "get", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ], "google.longrunning.Operations.ListOperations": [ { "method": "get", "uri": "/v1/{name=projects/*/locations/global}/operations", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, ], } @@ -1348,6 +1485,318 @@ def __call__( ) return resp + class _QueryOrgVpcFlowLogsConfigs( + _BaseVpcFlowLogsServiceRestTransport._BaseQueryOrgVpcFlowLogsConfigs, + VpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("VpcFlowLogsServiceRestTransport.QueryOrgVpcFlowLogsConfigs") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse: + r"""Call the query org vpc flow logs + configs method over HTTP. + + Args: + request (~.vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest): + The request object. Request for the ``QueryOrgVpcFlowLogsConfigs`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse: + Response for the ``QueryVpcFlowLogsConfigs`` method. + """ + + http_options = ( + _BaseVpcFlowLogsServiceRestTransport._BaseQueryOrgVpcFlowLogsConfigs._get_http_options() + ) + + request, metadata = self._interceptor.pre_query_org_vpc_flow_logs_configs( + request, metadata + ) + transcoded_request = _BaseVpcFlowLogsServiceRestTransport._BaseQueryOrgVpcFlowLogsConfigs._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseVpcFlowLogsServiceRestTransport._BaseQueryOrgVpcFlowLogsConfigs._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.VpcFlowLogsServiceClient.QueryOrgVpcFlowLogsConfigs", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "rpcName": "QueryOrgVpcFlowLogsConfigs", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = VpcFlowLogsServiceRestTransport._QueryOrgVpcFlowLogsConfigs._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() + pb_resp = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_query_org_vpc_flow_logs_configs(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_query_org_vpc_flow_logs_configs_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.VpcFlowLogsServiceClient.query_org_vpc_flow_logs_configs", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "rpcName": "QueryOrgVpcFlowLogsConfigs", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ShowEffectiveFlowLogsConfigs( + _BaseVpcFlowLogsServiceRestTransport._BaseShowEffectiveFlowLogsConfigs, + VpcFlowLogsServiceRestStub, + ): + def __hash__(self): + return hash("VpcFlowLogsServiceRestTransport.ShowEffectiveFlowLogsConfigs") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse: + r"""Call the show effective flow logs + configs method over HTTP. + + Args: + request (~.vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest): + The request object. Request for the ``ShowEffectiveFlowLogsConfigs`` 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, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse: + Response for the ``ShowEffectiveFlowLogsConfigs`` + method. + + """ + + http_options = ( + _BaseVpcFlowLogsServiceRestTransport._BaseShowEffectiveFlowLogsConfigs._get_http_options() + ) + + request, metadata = self._interceptor.pre_show_effective_flow_logs_configs( + request, metadata + ) + transcoded_request = _BaseVpcFlowLogsServiceRestTransport._BaseShowEffectiveFlowLogsConfigs._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseVpcFlowLogsServiceRestTransport._BaseShowEffectiveFlowLogsConfigs._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.networkmanagement_v1.VpcFlowLogsServiceClient.ShowEffectiveFlowLogsConfigs", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "rpcName": "ShowEffectiveFlowLogsConfigs", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = VpcFlowLogsServiceRestTransport._ShowEffectiveFlowLogsConfigs._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # 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 = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() + pb_resp = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_show_effective_flow_logs_configs(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_show_effective_flow_logs_configs_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.to_json( + response + ) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.networkmanagement_v1.VpcFlowLogsServiceClient.show_effective_flow_logs_configs", + extra={ + "serviceName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "rpcName": "ShowEffectiveFlowLogsConfigs", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + class _UpdateVpcFlowLogsConfig( _BaseVpcFlowLogsServiceRestTransport._BaseUpdateVpcFlowLogsConfig, VpcFlowLogsServiceRestStub, @@ -1547,6 +1996,28 @@ def list_vpc_flow_logs_configs( # In C++ this would require a dynamic_cast return self._ListVpcFlowLogsConfigs(self._session, self._host, self._interceptor) # type: ignore + @property + def query_org_vpc_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest], + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse, + ]: + # 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._QueryOrgVpcFlowLogsConfigs(self._session, self._host, self._interceptor) # type: ignore + + @property + def show_effective_flow_logs_configs( + self, + ) -> Callable[ + [vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest], + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse, + ]: + # 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._ShowEffectiveFlowLogsConfigs(self._session, self._host, self._interceptor) # type: ignore + @property def update_vpc_flow_logs_config( self, diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest_base.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest_base.py index 3f6ad8490cb1..d72408b47fae 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest_base.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/services/vpc_flow_logs_service/transports/rest_base.py @@ -291,6 +291,102 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseQueryOrgVpcFlowLogsConfigs: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/vpcFlowLogsConfigs:queryOrgVpcFlowLogsConfigs", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseVpcFlowLogsServiceRestTransport._BaseQueryOrgVpcFlowLogsConfigs._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseShowEffectiveFlowLogsConfigs: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "resource": "", + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/vpcFlowLogsConfigs:showEffectiveFlowLogsConfigs", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseVpcFlowLogsServiceRestTransport._BaseShowEffectiveFlowLogsConfigs._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseUpdateVpcFlowLogsConfig: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -361,6 +457,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*/locations/*}", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}", + }, ] return http_options @@ -386,6 +486,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*}/locations", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*}/locations", + }, ] return http_options @@ -499,6 +603,11 @@ def _get_http_options(): "uri": "/v1/{name=projects/*/locations/global/operations/*}:cancel", "body": "*", }, + { + "method": "post", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}:cancel", + "body": "*", + }, ] return http_options @@ -529,6 +638,10 @@ def _get_http_options(): "method": "delete", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "delete", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ] return http_options @@ -554,6 +667,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*/locations/global/operations/*}", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*/operations/*}", + }, ] return http_options @@ -579,6 +696,10 @@ def _get_http_options(): "method": "get", "uri": "/v1/{name=projects/*/locations/global}/operations", }, + { + "method": "get", + "uri": "/v1/{name=organizations/*/locations/*}/operations", + }, ] return http_options diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/__init__.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/__init__.py index f16fd271419d..cb0c83f545d3 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/__init__.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/__init__.py @@ -46,7 +46,9 @@ ForwardingRuleInfo, GKEMasterInfo, GoogleServiceInfo, + HybridSubnetInfo, InstanceInfo, + InterconnectAttachmentInfo, LoadBalancerBackend, LoadBalancerBackendInfo, LoadBalancerInfo, @@ -72,9 +74,13 @@ GetVpcFlowLogsConfigRequest, ListVpcFlowLogsConfigsRequest, ListVpcFlowLogsConfigsResponse, + QueryOrgVpcFlowLogsConfigsRequest, + QueryOrgVpcFlowLogsConfigsResponse, + ShowEffectiveFlowLogsConfigsRequest, + ShowEffectiveFlowLogsConfigsResponse, UpdateVpcFlowLogsConfigRequest, ) -from .vpc_flow_logs_config import VpcFlowLogsConfig +from .vpc_flow_logs_config import EffectiveVpcFlowLogsConfig, VpcFlowLogsConfig __all__ = ( "ConnectivityTest", @@ -105,7 +111,9 @@ "ForwardingRuleInfo", "GKEMasterInfo", "GoogleServiceInfo", + "HybridSubnetInfo", "InstanceInfo", + "InterconnectAttachmentInfo", "LoadBalancerBackend", "LoadBalancerBackendInfo", "LoadBalancerInfo", @@ -129,6 +137,11 @@ "GetVpcFlowLogsConfigRequest", "ListVpcFlowLogsConfigsRequest", "ListVpcFlowLogsConfigsResponse", + "QueryOrgVpcFlowLogsConfigsRequest", + "QueryOrgVpcFlowLogsConfigsResponse", + "ShowEffectiveFlowLogsConfigsRequest", + "ShowEffectiveFlowLogsConfigsResponse", "UpdateVpcFlowLogsConfigRequest", + "EffectiveVpcFlowLogsConfig", "VpcFlowLogsConfig", ) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/connectivity_test.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/connectivity_test.py index 6524ff13563b..a343b8b88a42 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/connectivity_test.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/connectivity_test.py @@ -362,11 +362,12 @@ class CloudRunRevisionEndpoint(proto.Message): A `Cloud Run `__ `revision `__ URI. The format is: - ``projects/{project}/locations/{location}/revisions/{revision}`` + projects/{project}/locations/{location}/revisions/{revision} service_uri (str): - Output only. The URI of the Cloud Run service that the - revision belongs to. The format is: - ``projects/{project}/locations/{location}/services/{service}`` + Output only. The URI of the Cloud Run service + that the revision belongs to. The format is: + + projects/{project}/locations/{location}/services/{service} """ uri: str = proto.Field( @@ -616,13 +617,17 @@ class ProbingDetails(proto.Message): direction: from the source to the destination endpoint. destination_egress_location (google.cloud.network_management_v1.types.ProbingDetails.EdgeLocation): - The EdgeLocation from which a packet destined - for/originating from the internet will egress/ingress the - Google network. This will only be populated for a - connectivity test which has an internet destination/source - address. The absence of this field *must not* be used as an - indication that the destination/source is part of the Google - network. + The EdgeLocation from which a packet, destined to the + internet, will egress the Google network. This will only be + populated for a connectivity test which has an internet + destination address. The absence of this field *must not* be + used as an indication that the destination is part of the + Google network. + edge_responses (MutableSequence[google.cloud.network_management_v1.types.ProbingDetails.SingleEdgeResponse]): + Probing results for all edge devices. + probed_all_devices (bool): + Whether all relevant edge devices were + probed. """ class ProbingResult(proto.Enum): @@ -685,6 +690,63 @@ class EdgeLocation(proto.Message): number=1, ) + class SingleEdgeResponse(proto.Message): + r"""Probing results for a single edge device. + + Attributes: + result (google.cloud.network_management_v1.types.ProbingDetails.ProbingResult): + The overall result of active probing for this + egress device. + sent_probe_count (int): + Number of probes sent. + successful_probe_count (int): + Number of probes that reached the + destination. + probing_latency (google.cloud.network_management_v1.types.LatencyDistribution): + Latency as measured by active probing in one + direction: from the source to the destination + endpoint. + destination_egress_location (google.cloud.network_management_v1.types.ProbingDetails.EdgeLocation): + The EdgeLocation from which a packet, destined to the + internet, will egress the Google network. This will only be + populated for a connectivity test which has an internet + destination address. The absence of this field *must not* be + used as an indication that the destination is part of the + Google network. + destination_router (str): + Router name in the format + '{router}.{metroshard}'. For example: + pf01.aaa01, pr02.aaa01. + """ + + result: "ProbingDetails.ProbingResult" = proto.Field( + proto.ENUM, + number=1, + enum="ProbingDetails.ProbingResult", + ) + sent_probe_count: int = proto.Field( + proto.INT32, + number=2, + ) + successful_probe_count: int = proto.Field( + proto.INT32, + number=3, + ) + probing_latency: "LatencyDistribution" = proto.Field( + proto.MESSAGE, + number=4, + message="LatencyDistribution", + ) + destination_egress_location: "ProbingDetails.EdgeLocation" = proto.Field( + proto.MESSAGE, + number=5, + message="ProbingDetails.EdgeLocation", + ) + destination_router: str = proto.Field( + proto.STRING, + number=6, + ) + result: ProbingResult = proto.Field( proto.ENUM, number=1, @@ -728,6 +790,15 @@ class EdgeLocation(proto.Message): number=9, message=EdgeLocation, ) + edge_responses: MutableSequence[SingleEdgeResponse] = proto.RepeatedField( + proto.MESSAGE, + number=10, + message=SingleEdgeResponse, + ) + probed_all_devices: bool = proto.Field( + proto.BOOL, + number=11, + ) __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/trace.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/trace.py index 46461d78fb5a..feca905f13a2 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/trace.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/trace.py @@ -33,8 +33,10 @@ "ForwardingRuleInfo", "LoadBalancerInfo", "LoadBalancerBackend", + "HybridSubnetInfo", "VpnGatewayInfo", "VpnTunnelInfo", + "InterconnectAttachmentInfo", "EndpointInfo", "DeliverInfo", "ForwardInfo", @@ -215,6 +217,10 @@ class Step(proto.Message): Display information of a Compute Engine forwarding rule. + This field is a member of `oneof`_ ``step_info``. + hybrid_subnet (google.cloud.network_management_v1.types.HybridSubnetInfo): + Display information of a hybrid subnet. + This field is a member of `oneof`_ ``step_info``. vpn_gateway (google.cloud.network_management_v1.types.VpnGatewayInfo): Display information of a Compute Engine VPN @@ -225,6 +231,11 @@ class Step(proto.Message): Display information of a Compute Engine VPN tunnel. + This field is a member of `oneof`_ ``step_info``. + interconnect_attachment (google.cloud.network_management_v1.types.InterconnectAttachmentInfo): + Display information of an interconnect + attachment. + This field is a member of `oneof`_ ``step_info``. vpc_connector (google.cloud.network_management_v1.types.VpcConnectorInfo): Display information of a VPC connector. @@ -411,21 +422,24 @@ class State(proto.Enum): Forwarding state: arriving at a Compute Engine instance. ARRIVE_AT_INTERNAL_LOAD_BALANCER (10): - Forwarding state: arriving at a Compute Engine internal load - balancer. Deprecated in favor of the - ``ANALYZE_LOAD_BALANCER_BACKEND`` state, not used in new - tests. + Forwarding state: arriving at a Compute + Engine internal load balancer. ARRIVE_AT_EXTERNAL_LOAD_BALANCER (11): - Forwarding state: arriving at a Compute Engine external load - balancer. Deprecated in favor of the - ``ANALYZE_LOAD_BALANCER_BACKEND`` state, not used in new - tests. + Forwarding state: arriving at a Compute + Engine external load balancer. + ARRIVE_AT_HYBRID_SUBNET (38): + Forwarding state: arriving at a hybrid + subnet. Appropriate routing configuration will + be determined here. ARRIVE_AT_VPN_GATEWAY (12): Forwarding state: arriving at a Cloud VPN gateway. ARRIVE_AT_VPN_TUNNEL (13): Forwarding state: arriving at a Cloud VPN tunnel. + ARRIVE_AT_INTERCONNECT_ATTACHMENT (37): + Forwarding state: arriving at an interconnect + attachment. ARRIVE_AT_VPC_CONNECTOR (24): Forwarding state: arriving at a VPC connector. @@ -438,7 +452,8 @@ class State(proto.Enum): from a serverless endpoint forwarded through public (external) connectivity. NAT (14): - Transition state: packet header translated. + Transition state: packet header translated. The ``nat`` + field is populated with the translation information. PROXY_CONNECTION (15): Transition state: original connection is terminated and a new proxied connection is @@ -481,8 +496,10 @@ class State(proto.Enum): ARRIVE_AT_INSTANCE = 9 ARRIVE_AT_INTERNAL_LOAD_BALANCER = 10 ARRIVE_AT_EXTERNAL_LOAD_BALANCER = 11 + ARRIVE_AT_HYBRID_SUBNET = 38 ARRIVE_AT_VPN_GATEWAY = 12 ARRIVE_AT_VPN_TUNNEL = 13 + ARRIVE_AT_INTERCONNECT_ATTACHMENT = 37 ARRIVE_AT_VPC_CONNECTOR = 24 DIRECT_VPC_EGRESS_CONNECTION = 35 SERVERLESS_EXTERNAL_CONNECTION = 36 @@ -547,6 +564,12 @@ class State(proto.Enum): oneof="step_info", message="ForwardingRuleInfo", ) + hybrid_subnet: "HybridSubnetInfo" = proto.Field( + proto.MESSAGE, + number=36, + oneof="step_info", + message="HybridSubnetInfo", + ) vpn_gateway: "VpnGatewayInfo" = proto.Field( proto.MESSAGE, number=10, @@ -559,6 +582,12 @@ class State(proto.Enum): oneof="step_info", message="VpnTunnelInfo", ) + interconnect_attachment: "InterconnectAttachmentInfo" = proto.Field( + proto.MESSAGE, + number=35, + oneof="step_info", + message="InterconnectAttachmentInfo", + ) vpc_connector: "VpcConnectorInfo" = proto.Field( proto.MESSAGE, number=21, @@ -712,8 +741,30 @@ class InstanceInfo(proto.Message): psc_network_attachment_uri (str): URI of the PSC network attachment the NIC is attached to (if relevant). + running (bool): + Indicates whether the Compute Engine instance is running. + Deprecated: use the ``status`` field instead. + status (google.cloud.network_management_v1.types.InstanceInfo.Status): + The status of the instance. """ + class Status(proto.Enum): + r"""The status of the instance. We treat all states other than + "RUNNING" as not running. + + Values: + STATUS_UNSPECIFIED (0): + Default unspecified value. + RUNNING (1): + The instance is running. + NOT_RUNNING (2): + The instance has any status other than + "RUNNING". + """ + STATUS_UNSPECIFIED = 0 + RUNNING = 1 + NOT_RUNNING = 2 + display_name: str = proto.Field( proto.STRING, number=1, @@ -750,11 +801,20 @@ class InstanceInfo(proto.Message): proto.STRING, number=9, ) + running: bool = proto.Field( + proto.BOOL, + number=10, + ) + status: Status = proto.Field( + proto.ENUM, + number=11, + enum=Status, + ) class NetworkInfo(proto.Message): r"""For display only. Metadata associated with a Compute Engine - network. Next ID: 7 + network. Attributes: display_name (str): @@ -835,6 +895,13 @@ class FirewallInfo(proto.Message): rules. firewall_rule_type (google.cloud.network_management_v1.types.FirewallInfo.FirewallRuleType): The firewall rule's type. + policy_priority (int): + The priority of the firewall policy that this + rule is associated with. This field is not + applicable to VPC firewall rules and implied VPC + firewall rules. + target_type (google.cloud.network_management_v1.types.FirewallInfo.TargetType): + Target type of the firewall rule. """ class FirewallRuleType(proto.Enum): @@ -894,6 +961,24 @@ class FirewallRuleType(proto.Enum): TRACKING_STATE = 101 ANALYSIS_SKIPPED = 102 + class TargetType(proto.Enum): + r"""Target type of the firewall rule. + + Values: + TARGET_TYPE_UNSPECIFIED (0): + Target type is not specified. In this case we + treat the rule as applying to INSTANCES target + type. + INSTANCES (1): + Firewall rule applies to instances. + INTERNAL_MANAGED_LB (2): + Firewall rule applies to internal managed + load balancers. + """ + TARGET_TYPE_UNSPECIFIED = 0 + INSTANCES = 1 + INTERNAL_MANAGED_LB = 2 + display_name: str = proto.Field( proto.STRING, number=1, @@ -939,6 +1024,15 @@ class FirewallRuleType(proto.Enum): number=10, enum=FirewallRuleType, ) + policy_priority: int = proto.Field( + proto.INT32, + number=12, + ) + target_type: TargetType = proto.Field( + proto.ENUM, + number=13, + enum=TargetType, + ) class RouteInfo(proto.Message): @@ -1116,6 +1210,8 @@ class NextHopType(proto.Enum): happens when the user doesn't have permissions to the project where the next hop resource is located. + SECURE_WEB_PROXY_GATEWAY (13): + Next hop is Secure Web Proxy Gateway. """ NEXT_HOP_TYPE_UNSPECIFIED = 0 NEXT_HOP_IP = 1 @@ -1130,6 +1226,7 @@ class NextHopType(proto.Enum): NEXT_HOP_ILB = 10 NEXT_HOP_ROUTER_APPLIANCE = 11 NEXT_HOP_NCC_HUB = 12 + SECURE_WEB_PROXY_GATEWAY = 13 class RouteScope(proto.Enum): r"""Indicates where routes are applicable. @@ -1561,6 +1658,33 @@ class HealthCheckFirewallState(proto.Enum): ) +class HybridSubnetInfo(proto.Message): + r"""For display only. Metadata associated with a hybrid subnet. + + Attributes: + display_name (str): + Name of a hybrid subnet. + uri (str): + URI of a hybrid subnet. + region (str): + Name of a Google Cloud region where the + hybrid subnet is configured. + """ + + display_name: str = proto.Field( + proto.STRING, + number=1, + ) + uri: str = proto.Field( + proto.STRING, + number=2, + ) + region: str = proto.Field( + proto.STRING, + number=3, + ) + + class VpnGatewayInfo(proto.Message): r"""For display only. Metadata associated with a Compute Engine VPN gateway. @@ -1699,6 +1823,86 @@ class RoutingType(proto.Enum): ) +class InterconnectAttachmentInfo(proto.Message): + r"""For display only. Metadata associated with an Interconnect + attachment. + + Attributes: + display_name (str): + Name of an Interconnect attachment. + uri (str): + URI of an Interconnect attachment. + interconnect_uri (str): + URI of the Interconnect where the + Interconnect attachment is configured. + region (str): + Name of a Google Cloud region where the + Interconnect attachment is configured. + cloud_router_uri (str): + URI of the Cloud Router to be used for + dynamic routing. + type_ (google.cloud.network_management_v1.types.InterconnectAttachmentInfo.Type): + The type of interconnect attachment this is. + l2_attachment_matched_ip_address (str): + Appliance IP address that was matched for L2_DEDICATED + attachments. + """ + + class Type(proto.Enum): + r"""What type of interconnect attachment this is. + + Values: + TYPE_UNSPECIFIED (0): + Unspecified type. + DEDICATED (1): + Attachment to a dedicated interconnect. + PARTNER (2): + Attachment to a partner interconnect, created + by the customer. + PARTNER_PROVIDER (3): + Attachment to a partner interconnect, created + by the partner. + L2_DEDICATED (4): + Attachment to a L2 interconnect, created by + the customer. + """ + TYPE_UNSPECIFIED = 0 + DEDICATED = 1 + PARTNER = 2 + PARTNER_PROVIDER = 3 + L2_DEDICATED = 4 + + display_name: str = proto.Field( + proto.STRING, + number=1, + ) + uri: str = proto.Field( + proto.STRING, + number=2, + ) + interconnect_uri: str = proto.Field( + proto.STRING, + number=3, + ) + region: str = proto.Field( + proto.STRING, + number=4, + ) + cloud_router_uri: str = proto.Field( + proto.STRING, + number=5, + ) + type_: Type = proto.Field( + proto.ENUM, + number=6, + enum=Type, + ) + l2_attachment_matched_ip_address: str = proto.Field( + proto.STRING, + number=7, + ) + + class EndpointInfo(proto.Message): r"""For display only. The specification of the endpoints for the test. EndpointInfo is derived from source and destination @@ -1780,6 +1984,9 @@ class DeliverInfo(proto.Message): psc_google_api_target (str): PSC Google API target the packet is delivered to (if applicable). + google_service_type (google.cloud.network_management_v1.types.DeliverInfo.GoogleServiceType): + Recognized type of a Google Service the + packet is delivered to (if applicable). """ class Target(proto.Enum): @@ -1852,6 +2059,43 @@ class Target(proto.Enum): REDIS_INSTANCE = 16 REDIS_CLUSTER = 17 + class GoogleServiceType(proto.Enum): + r"""Recognized type of a Google Service. + + Values: + GOOGLE_SERVICE_TYPE_UNSPECIFIED (0): + Unspecified Google Service. + IAP (1): + Identity aware proxy. + https://cloud.google.com/iap/docs/using-tcp-forwarding + GFE_PROXY_OR_HEALTH_CHECK_PROBER (2): + One of two services sharing IP ranges: + + - Load Balancer proxy + - Centralized Health Check prober + https://cloud.google.com/load-balancing/docs/firewall-rules + CLOUD_DNS (3): + Connectivity from Cloud DNS to forwarding + targets or alternate name servers that use + private routing. + https://cloud.google.com/dns/docs/zones/forwarding-zones#firewall-rules + https://cloud.google.com/dns/docs/policies#firewall-rules + PRIVATE_GOOGLE_ACCESS (4): + private.googleapis.com and + restricted.googleapis.com + SERVERLESS_VPC_ACCESS (5): + Google API via Private Service Connect. + https://cloud.google.com/vpc/docs/configure-private-service-connect-apis + Google API via Serverless VPC Access. + https://cloud.google.com/vpc/docs/serverless-vpc-access + """ + GOOGLE_SERVICE_TYPE_UNSPECIFIED = 0 + IAP = 1 + GFE_PROXY_OR_HEALTH_CHECK_PROBER = 2 + CLOUD_DNS = 3 + PRIVATE_GOOGLE_ACCESS = 4 + SERVERLESS_VPC_ACCESS = 5 + target: Target = proto.Field( proto.ENUM, number=1, @@ -1873,6 +2117,11 @@ class Target(proto.Enum): proto.STRING, number=5, ) + google_service_type: GoogleServiceType = proto.Field( + proto.ENUM, + number=6, + enum=GoogleServiceType, + ) class ForwardInfo(proto.Message): @@ -1916,6 +2165,8 @@ class Target(proto.Enum): Forwarded to an NCC Hub. ROUTER_APPLIANCE (9): Forwarded to a router appliance. + SECURE_WEB_PROXY_GATEWAY (10): + Forwarded to a Secure Web Proxy Gateway. """ TARGET_UNSPECIFIED = 0 PEERING_VPC = 1 @@ -1927,6 +2178,7 @@ class Target(proto.Enum): ANOTHER_PROJECT = 7 NCC_HUB = 8 ROUTER_APPLIANCE = 9 + SECURE_WEB_PROXY_GATEWAY = 10 target: Target = proto.Field( proto.ENUM, @@ -2072,9 +2324,13 @@ class Cause(proto.Enum): Aborted because expected route configuration was missing. GOOGLE_MANAGED_SERVICE_AMBIGUOUS_PSC_ENDPOINT (19): - Aborted because a PSC endpoint selection for + Aborted because PSC endpoint selection for the Google-managed service is ambiguous (several PSC endpoints satisfy test input). + GOOGLE_MANAGED_SERVICE_AMBIGUOUS_ENDPOINT (39): + Aborted because endpoint selection for the + Google-managed service is ambiguous (several + endpoints satisfy test input). SOURCE_PSC_CLOUD_SQL_UNSUPPORTED (20): Aborted because tests with a PSC-based Cloud SQL instance as a source are not supported. @@ -2102,6 +2358,9 @@ class Cause(proto.Enum): Cloud Run revision with direct VPC access enabled, but there are no reserved serverless IP ranges. + IP_VERSION_PROTOCOL_MISMATCH (40): + Aborted because the used protocol is not + supported for the used IP version. """ CAUSE_UNSPECIFIED = 0 UNKNOWN_NETWORK = 1 @@ -2132,6 +2391,7 @@ class Cause(proto.Enum): FIREWALL_CONFIG_NOT_FOUND = 26 ROUTE_CONFIG_NOT_FOUND = 27 GOOGLE_MANAGED_SERVICE_AMBIGUOUS_PSC_ENDPOINT = 19 + GOOGLE_MANAGED_SERVICE_AMBIGUOUS_ENDPOINT = 39 SOURCE_PSC_CLOUD_SQL_UNSUPPORTED = 20 SOURCE_REDIS_CLUSTER_UNSUPPORTED = 34 SOURCE_REDIS_INSTANCE_UNSUPPORTED = 35 @@ -2140,6 +2400,7 @@ class Cause(proto.Enum): UNKNOWN_ISSUE_IN_GOOGLE_MANAGED_PROJECT = 30 UNSUPPORTED_GOOGLE_MANAGED_PROJECT_CONFIG = 31 NO_SERVERLESS_IP_RANGES = 37 + IP_VERSION_PROTOCOL_MISMATCH = 40 cause: Cause = proto.Field( proto.ENUM, @@ -2176,6 +2437,12 @@ class DropInfo(proto.Message): (if relevant). region (str): Region of the dropped packet (if relevant). + source_geolocation_code (str): + Geolocation (region code) of the source IP + address (if relevant). + destination_geolocation_code (str): + Geolocation (region code) of the destination + IP address (if relevant). """ class Cause(proto.Enum): @@ -2228,8 +2495,12 @@ class Cause(proto.Enum): invalid (it's not a forwarding rule of the internal passthrough load balancer). NO_ROUTE_FROM_INTERNET_TO_PRIVATE_IPV6_ADDRESS (44): - Packet is sent from the Internet to the - private IPv6 address. + Packet is sent from the Internet or Google + service to the private IPv6 address. + NO_ROUTE_FROM_EXTERNAL_IPV6_SOURCE_TO_PRIVATE_IPV6_ADDRESS (98): + Packet is sent from the external IPv6 source + address of an instance to the private IPv6 + address of an instance. VPN_TUNNEL_LOCAL_SELECTOR_MISMATCH (45): The packet does not match a policy-based VPN tunnel local selector. @@ -2240,20 +2511,19 @@ class Cause(proto.Enum): Packet with internal destination address sent to the internet gateway. PRIVATE_GOOGLE_ACCESS_DISALLOWED (8): - Instance with only an internal IP address + Endpoint with only an internal IP address tries to access Google API and services, but - private Google access is not enabled in the - subnet. + Private Google Access is not enabled in the + subnet or is not applicable. PRIVATE_GOOGLE_ACCESS_VIA_VPN_TUNNEL_UNSUPPORTED (47): Source endpoint tries to access Google API and services through the VPN tunnel to another network, but Private Google Access needs to be enabled in the source endpoint network. NO_EXTERNAL_ADDRESS (9): - Instance with only an internal IP address - tries to access external hosts, but Cloud NAT is - not enabled in the subnet, unless special - configurations on a VM allow this connection. + Endpoint with only an internal IP address + tries to access external hosts, but there is no + matching Cloud NAT gateway in the subnet. UNKNOWN_INTERNAL_ADDRESS (10): Destination internal address cannot be resolved to a known target. If this is a shared @@ -2516,6 +2786,46 @@ class Cause(proto.Enum): Packet with destination IP address within the reserved NAT64 range is dropped due to matching a route of an unsupported type. + TRAFFIC_FROM_HYBRID_ENDPOINT_TO_INTERNET_DISALLOWED (89): + Packet could be dropped because hybrid + endpoint like a VPN gateway or Interconnect is + not allowed to send traffic to the Internet. + NO_MATCHING_NAT64_GATEWAY (90): + Packet with destination IP address within the + reserved NAT64 range is dropped due to no + matching NAT gateway in the subnet. + LOAD_BALANCER_BACKEND_IP_VERSION_MISMATCH (96): + Packet is dropped due to being sent to a + backend of a passthrough load balancer that + doesn't use the same IP version as the frontend. + NO_KNOWN_ROUTE_FROM_NCC_NETWORK_TO_DESTINATION (97): + Packet from the unknown NCC network is + dropped due to no known route from the source + network to the destination IP address. + CLOUD_NAT_PROTOCOL_UNSUPPORTED (99): + Packet is dropped by Cloud NAT due to using + an unsupported protocol. + L2_INTERCONNECT_UNSUPPORTED_PROTOCOL (100): + Packet is dropped due to using an unsupported + protocol (any other than UDP) for L2 + Interconnect. + L2_INTERCONNECT_UNSUPPORTED_PORT (101): + Packet is dropped due to using an unsupported + port (any other than 6081) for L2 Interconnect. + L2_INTERCONNECT_DESTINATION_IP_MISMATCH (102): + Packet is dropped due to destination IP not + matching the appliance mapping IPs configured on + the L2 Interconnect attachment. + NCC_ROUTE_WITHIN_HYBRID_SUBNET_UNSUPPORTED (104): + Packet could be dropped because it matches a + route associated with an NCC spoke in the hybrid + subnet context, but such a configuration is not + supported. + HYBRID_SUBNET_REGION_MISMATCH (105): + Packet is dropped because the region of the + hybrid subnet is different from the region of + the next hop of the route matched within this + hybrid subnet. """ CAUSE_UNSPECIFIED = 0 UNKNOWN_EXTERNAL_ADDRESS = 1 @@ -2532,6 +2842,7 @@ class Cause(proto.Enum): ROUTE_NEXT_HOP_VPN_TUNNEL_NOT_ESTABLISHED = 52 ROUTE_NEXT_HOP_FORWARDING_RULE_TYPE_INVALID = 53 NO_ROUTE_FROM_INTERNET_TO_PRIVATE_IPV6_ADDRESS = 44 + NO_ROUTE_FROM_EXTERNAL_IPV6_SOURCE_TO_PRIVATE_IPV6_ADDRESS = 98 VPN_TUNNEL_LOCAL_SELECTOR_MISMATCH = 45 VPN_TUNNEL_REMOTE_SELECTOR_MISMATCH = 46 PRIVATE_TRAFFIC_TO_INTERNET = 7 @@ -2605,6 +2916,16 @@ class Cause(proto.Enum): PSC_PORT_MAPPING_PORT_MISMATCH = 86 PSC_PORT_MAPPING_WITHOUT_PSC_CONNECTION_UNSUPPORTED = 87 UNSUPPORTED_ROUTE_MATCHED_FOR_NAT64_DESTINATION = 88 + TRAFFIC_FROM_HYBRID_ENDPOINT_TO_INTERNET_DISALLOWED = 89 + NO_MATCHING_NAT64_GATEWAY = 90 + LOAD_BALANCER_BACKEND_IP_VERSION_MISMATCH = 96 + NO_KNOWN_ROUTE_FROM_NCC_NETWORK_TO_DESTINATION = 97 + CLOUD_NAT_PROTOCOL_UNSUPPORTED = 99 + L2_INTERCONNECT_UNSUPPORTED_PROTOCOL = 100 + L2_INTERCONNECT_UNSUPPORTED_PORT = 101 + L2_INTERCONNECT_DESTINATION_IP_MISMATCH = 102 + NCC_ROUTE_WITHIN_HYBRID_SUBNET_UNSUPPORTED = 104 + HYBRID_SUBNET_REGION_MISMATCH = 105 cause: Cause = proto.Field( proto.ENUM, @@ -2627,6 +2948,14 @@ class Cause(proto.Enum): proto.STRING, number=5, ) + source_geolocation_code: str = proto.Field( + proto.STRING, + number=6, + ) + destination_geolocation_code: str = proto.Field( + proto.STRING, + number=7, + ) class GKEMasterInfo(proto.Message): @@ -3056,12 +3385,15 @@ class Type(proto.Enum): Cloud NAT Gateway. PRIVATE_SERVICE_CONNECT (4): Private service connect NAT. + GKE_POD_IP_MASQUERADING (5): + GKE Pod IP address masquerading. """ TYPE_UNSPECIFIED = 0 INTERNAL_TO_EXTERNAL = 1 EXTERNAL_TO_INTERNAL = 2 CLOUD_NAT = 3 PRIVATE_SERVICE_CONNECT = 4 + GKE_POD_IP_MASQUERADING = 5 type_: Type = proto.Field( proto.ENUM, diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs.py index 713b5b9ddf46..4b3746f0e842 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs.py @@ -33,6 +33,10 @@ "CreateVpcFlowLogsConfigRequest", "UpdateVpcFlowLogsConfigRequest", "DeleteVpcFlowLogsConfigRequest", + "QueryOrgVpcFlowLogsConfigsRequest", + "QueryOrgVpcFlowLogsConfigsResponse", + "ShowEffectiveFlowLogsConfigsRequest", + "ShowEffectiveFlowLogsConfigsResponse", }, ) @@ -42,8 +46,14 @@ class ListVpcFlowLogsConfigsRequest(proto.Message): Attributes: parent (str): - Required. The parent resource of the VpcFlowLogsConfig: - ``projects/{project_id}/locations/global`` + Required. The parent resource of the VpcFlowLogsConfig, in + one of the following formats: + + - For project-level resourcs: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` page_size (int): Optional. Number of ``VpcFlowLogsConfigs`` to return. page_token (str): @@ -120,9 +130,14 @@ class GetVpcFlowLogsConfigRequest(proto.Message): Attributes: name (str): - Required. ``VpcFlowLogsConfig`` resource name using the - form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config}`` + Required. The resource name of the VpcFlowLogsConfig, in one + of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` """ name: str = proto.Field( @@ -136,9 +151,14 @@ class CreateVpcFlowLogsConfigRequest(proto.Message): Attributes: parent (str): - Required. The parent resource of the VPC Flow Logs - configuration to create: - ``projects/{project_id}/locations/global`` + Required. The parent resource of the VpcFlowLogsConfig to + create, in one of the following formats: + + - For project-level resources: + ``projects/{project_id}/locations/global`` + + - For organization-level resources: + ``organizations/{organization_id}/locations/global`` vpc_flow_logs_config_id (str): Required. ID of the ``VpcFlowLogsConfig``. vpc_flow_logs_config (google.cloud.network_management_v1.types.VpcFlowLogsConfig): @@ -165,8 +185,11 @@ class UpdateVpcFlowLogsConfigRequest(proto.Message): Attributes: update_mask (google.protobuf.field_mask_pb2.FieldMask): - Required. Mask of fields to update. At least - one path must be supplied in this field. + Required. Mask of fields to update. At least one path must + be supplied in this field. For example, to change the state + of the configuration to ENABLED, specify ``update_mask`` = + ``"state"``, and the ``vpc_flow_logs_config`` would be: + ``vpc_flow_logs_config = { name = "projects/my-project/locations/global/vpcFlowLogsConfigs/my-config" state = "ENABLED" }`` vpc_flow_logs_config (google.cloud.network_management_v1.types.VpcFlowLogsConfig): Required. Only fields specified in update_mask are updated. """ @@ -188,9 +211,14 @@ class DeleteVpcFlowLogsConfigRequest(proto.Message): Attributes: name (str): - Required. ``VpcFlowLogsConfig`` resource name using the - form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config}`` + Required. The resource name of the VpcFlowLogsConfig, in one + of the following formats: + + - For a project-level resource: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For an organization-level resource: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` """ name: str = proto.Field( @@ -199,4 +227,163 @@ class DeleteVpcFlowLogsConfigRequest(proto.Message): ) +class QueryOrgVpcFlowLogsConfigsRequest(proto.Message): + r"""Request for the ``QueryOrgVpcFlowLogsConfigs`` method. + + Attributes: + parent (str): + Required. The parent resource of the VpcFlowLogsConfig, + specified in the following format: + ``projects/{project_id}/locations/global`` + page_size (int): + Optional. Number of ``VpcFlowLogsConfigs`` to return. + page_token (str): + Optional. Page token from an earlier query, as returned in + ``next_page_token``. + filter (str): + Optional. Lists the ``VpcFlowLogsConfigs`` that match the + filter expression. A filter expression must use the + supported [CEL logic operators] + (https://cloud.google.com/vpc/docs/about-flow-logs-records#supported_cel_logic_operators). + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + page_size: int = proto.Field( + proto.INT32, + number=2, + ) + page_token: str = proto.Field( + proto.STRING, + number=3, + ) + filter: str = proto.Field( + proto.STRING, + number=4, + ) + + +class QueryOrgVpcFlowLogsConfigsResponse(proto.Message): + r"""Response for the ``QueryVpcFlowLogsConfigs`` method. + + Attributes: + vpc_flow_logs_configs (MutableSequence[google.cloud.network_management_v1.types.VpcFlowLogsConfig]): + List of VPC Flow Log configurations. + next_page_token (str): + Page token to fetch the next set of + configurations. + unreachable (MutableSequence[str]): + Locations that could not be reached (when querying all + locations with ``-``). + """ + + @property + def raw_page(self): + return self + + vpc_flow_logs_configs: MutableSequence[ + gcn_vpc_flow_logs_config.VpcFlowLogsConfig + ] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=gcn_vpc_flow_logs_config.VpcFlowLogsConfig, + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + unreachable: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=3, + ) + + +class ShowEffectiveFlowLogsConfigsRequest(proto.Message): + r"""Request for the ``ShowEffectiveFlowLogsConfigs`` method. + + Attributes: + parent (str): + Required. The parent resource of the VpcFlowLogsConfig, + specified in the following format: + ``projects/{project_id}/locations/global`` + resource (str): + Required. The resource to get the effective + VPC Flow Logs configuration for. The resource + must belong to the same project as the parent. + The resource must be a network, subnetwork, + interconnect attachment, VPN tunnel, or a + project. + page_size (int): + Optional. Number of ``EffectiveVpcFlowLogsConfigs`` to + return. Default is 30. + page_token (str): + Optional. Page token from an earlier query, as returned in + ``next_page_token``. + filter (str): + Optional. Lists the ``EffectiveVpcFlowLogsConfigs`` that + match the filter expression. A filter expression must use + the supported [CEL logic operators] + (https://cloud.google.com/vpc/docs/about-flow-logs-records#supported_cel_logic_operators). + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + resource: str = proto.Field( + proto.STRING, + number=2, + ) + page_size: int = proto.Field( + proto.INT32, + number=3, + ) + page_token: str = proto.Field( + proto.STRING, + number=4, + ) + filter: str = proto.Field( + proto.STRING, + number=5, + ) + + +class ShowEffectiveFlowLogsConfigsResponse(proto.Message): + r"""Response for the ``ShowEffectiveFlowLogsConfigs`` method. + + Attributes: + effective_flow_logs_configs (MutableSequence[google.cloud.network_management_v1.types.EffectiveVpcFlowLogsConfig]): + List of Effective Vpc Flow Logs + configurations. + next_page_token (str): + Page token to fetch the next set of + configurations. + unreachable (MutableSequence[str]): + Locations that could not be reached (when querying all + locations with ``-``). + """ + + @property + def raw_page(self): + return self + + effective_flow_logs_configs: MutableSequence[ + gcn_vpc_flow_logs_config.EffectiveVpcFlowLogsConfig + ] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=gcn_vpc_flow_logs_config.EffectiveVpcFlowLogsConfig, + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + unreachable: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=3, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs_config.py b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs_config.py index c1f2da89ef74..9007f989019f 100644 --- a/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs_config.py +++ b/packages/google-cloud-network-management/google/cloud/network_management_v1/types/vpc_flow_logs_config.py @@ -24,6 +24,7 @@ package="google.cloud.networkmanagement.v1", manifest={ "VpcFlowLogsConfig", + "EffectiveVpcFlowLogsConfig", }, ) @@ -40,8 +41,14 @@ class VpcFlowLogsConfig(proto.Message): Attributes: name (str): - Identifier. Unique name of the configuration using the form: - ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + Identifier. Unique name of the configuration. The name can + have one of the following forms: + + - For project-level configurations: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level configurations: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` description (str): Optional. The user-supplied description of the VPC Flow Logs configuration. Maximum of 512 @@ -52,7 +59,8 @@ class VpcFlowLogsConfig(proto.Message): Optional. The state of the VPC Flow Log configuration. Default value is ENABLED. When creating a new configuration, it must be - enabled. + enabled. Setting state=DISABLED will pause the + log generation for this config. This field is a member of `oneof`_ ``_state``. aggregation_interval (google.cloud.network_management_v1.types.VpcFlowLogsConfig.AggregationInterval): @@ -83,12 +91,31 @@ class VpcFlowLogsConfig(proto.Message): VPC Flow Logs should be logged. This field is a member of `oneof`_ ``_filter_expr``. + cross_project_metadata (google.cloud.network_management_v1.types.VpcFlowLogsConfig.CrossProjectMetadata): + Optional. Determines whether to include cross project + annotations in the logs. This field is available only for + organization configurations. If not specified in org configs + will be set to CROSS_PROJECT_METADATA_ENABLED. + + This field is a member of `oneof`_ ``_cross_project_metadata``. target_resource_state (google.cloud.network_management_v1.types.VpcFlowLogsConfig.TargetResourceState): - Output only. A diagnostic bit - describes the - state of the configured target resource for - diagnostic purposes. + Output only. Describes the state of the + configured target resource for diagnostic + purposes. This field is a member of `oneof`_ ``_target_resource_state``. + network (str): + Traffic will be logged from VMs, VPN tunnels and + Interconnect Attachments within the network. Format: + projects/{project_id}/global/networks/{name} + + This field is a member of `oneof`_ ``target_resource``. + subnet (str): + Traffic will be logged from VMs within the subnetwork. + Format: + projects/{project_id}/regions/{region}/subnetworks/{name} + + This field is a member of `oneof`_ ``target_resource``. interconnect_attachment (str): Traffic will be logged from the Interconnect Attachment. Format: @@ -111,8 +138,7 @@ class VpcFlowLogsConfig(proto.Message): class State(proto.Enum): r"""Determines whether this configuration will be generating - logs. Setting state=DISABLED will pause the log generation for - this config. + logs. Values: STATE_UNSPECIFIED (0): @@ -174,9 +200,29 @@ class Metadata(proto.Enum): EXCLUDE_ALL_METADATA = 2 CUSTOM_METADATA = 3 + class CrossProjectMetadata(proto.Enum): + r"""Determines whether to include cross project annotations in the logs. + Project configurations will always have + CROSS_PROJECT_METADATA_DISABLED. + + Values: + CROSS_PROJECT_METADATA_UNSPECIFIED (0): + If not specified, the default is + CROSS_PROJECT_METADATA_ENABLED. + CROSS_PROJECT_METADATA_ENABLED (1): + When CROSS_PROJECT_METADATA_ENABLED, metadata from other + projects will be included in the logs. + CROSS_PROJECT_METADATA_DISABLED (2): + When CROSS_PROJECT_METADATA_DISABLED, metadata from other + projects will not be included in the logs. + """ + CROSS_PROJECT_METADATA_UNSPECIFIED = 0 + CROSS_PROJECT_METADATA_ENABLED = 1 + CROSS_PROJECT_METADATA_DISABLED = 2 + class TargetResourceState(proto.Enum): - r"""Optional states of the target resource that are used as part - of the diagnostic bit. + r"""Output only. Indicates whether the target resource exists, + for diagnostic purposes. Values: TARGET_RESOURCE_STATE_UNSPECIFIED (0): @@ -232,12 +278,28 @@ class TargetResourceState(proto.Enum): number=8, optional=True, ) + cross_project_metadata: CrossProjectMetadata = proto.Field( + proto.ENUM, + number=13, + optional=True, + enum=CrossProjectMetadata, + ) target_resource_state: TargetResourceState = proto.Field( proto.ENUM, number=12, optional=True, enum=TargetResourceState, ) + network: str = proto.Field( + proto.STRING, + number=100, + oneof="target_resource", + ) + subnet: str = proto.Field( + proto.STRING, + number=101, + oneof="target_resource", + ) interconnect_attachment: str = proto.Field( proto.STRING, number=102, @@ -265,4 +327,203 @@ class TargetResourceState(proto.Enum): ) +class EffectiveVpcFlowLogsConfig(proto.Message): + r"""A configuration to generate a response for + GetEffectiveVpcFlowLogsConfig request. + + This message has `oneof`_ fields (mutually exclusive fields). + For each oneof, at most one member field can be set at the same time. + Setting any member of the oneof automatically clears all other + members. + + .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields + + Attributes: + name (str): + Unique name of the configuration. The name can have one of + the following forms: + + - For project-level configurations: + ``projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For organization-level configurations: + ``organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`` + + - For a Compute config, the name will be the path of the + subnet: + ``projects/{project_id}/regions/{region}/subnetworks/{subnet_id}`` + state (google.cloud.network_management_v1.types.VpcFlowLogsConfig.State): + The state of the VPC Flow Log configuration. + Default value is ENABLED. When creating a new + configuration, it must be enabled. Setting + state=DISABLED will pause the log generation for + this config. + + This field is a member of `oneof`_ ``_state``. + aggregation_interval (google.cloud.network_management_v1.types.VpcFlowLogsConfig.AggregationInterval): + The aggregation interval for the logs. Default value is + INTERVAL_5_SEC. + + This field is a member of `oneof`_ ``_aggregation_interval``. + flow_sampling (float): + The value of the field must be in (0, 1]. The sampling rate + of VPC Flow Logs where 1.0 means all collected logs are + reported. Setting the sampling rate to 0.0 is not allowed. + If you want to disable VPC Flow Logs, use the state field + instead. Default value is 1.0. + + This field is a member of `oneof`_ ``_flow_sampling``. + metadata (google.cloud.network_management_v1.types.VpcFlowLogsConfig.Metadata): + Configures whether all, none or a subset of metadata fields + should be added to the reported VPC flow logs. Default value + is INCLUDE_ALL_METADATA. + + This field is a member of `oneof`_ ``_metadata``. + metadata_fields (MutableSequence[str]): + Custom metadata fields to include in the reported VPC flow + logs. Can only be specified if "metadata" was set to + CUSTOM_METADATA. + filter_expr (str): + Export filter used to define which VPC Flow + Logs should be logged. + + This field is a member of `oneof`_ ``_filter_expr``. + cross_project_metadata (google.cloud.network_management_v1.types.VpcFlowLogsConfig.CrossProjectMetadata): + Determines whether to include cross project annotations in + the logs. This field is available only for organization + configurations. If not specified in org configs will be set + to CROSS_PROJECT_METADATA_ENABLED. + + This field is a member of `oneof`_ ``_cross_project_metadata``. + network (str): + Traffic will be logged from VMs, VPN tunnels and + Interconnect Attachments within the network. Format: + projects/{project_id}/global/networks/{name} + + This field is a member of `oneof`_ ``target_resource``. + subnet (str): + Traffic will be logged from VMs within the subnetwork. + Format: + projects/{project_id}/regions/{region}/subnetworks/{name} + + This field is a member of `oneof`_ ``target_resource``. + interconnect_attachment (str): + Traffic will be logged from the Interconnect Attachment. + Format: + projects/{project_id}/regions/{region}/interconnectAttachments/{name} + + This field is a member of `oneof`_ ``target_resource``. + vpn_tunnel (str): + Traffic will be logged from the VPN Tunnel. Format: + projects/{project_id}/regions/{region}/vpnTunnels/{name} + + This field is a member of `oneof`_ ``target_resource``. + scope (google.cloud.network_management_v1.types.EffectiveVpcFlowLogsConfig.Scope): + Specifies the scope of the config (e.g., + SUBNET, NETWORK, ORGANIZATION..). + + This field is a member of `oneof`_ ``_scope``. + """ + + class Scope(proto.Enum): + r"""The scope for this flow log configuration. + + Values: + SCOPE_UNSPECIFIED (0): + Scope is unspecified. + SUBNET (1): + Target resource is a subnet (Network + Management API). + COMPUTE_API_SUBNET (2): + Target resource is a subnet, and the config + originates from the Compute API. + NETWORK (3): + Target resource is a network. + VPN_TUNNEL (4): + Target resource is a VPN tunnel. + INTERCONNECT_ATTACHMENT (5): + Target resource is an interconnect + attachment. + ORGANIZATION (6): + Configuration applies to an entire + organization. + """ + SCOPE_UNSPECIFIED = 0 + SUBNET = 1 + COMPUTE_API_SUBNET = 2 + NETWORK = 3 + VPN_TUNNEL = 4 + INTERCONNECT_ATTACHMENT = 5 + ORGANIZATION = 6 + + name: str = proto.Field( + proto.STRING, + number=1, + ) + state: "VpcFlowLogsConfig.State" = proto.Field( + proto.ENUM, + number=3, + optional=True, + enum="VpcFlowLogsConfig.State", + ) + aggregation_interval: "VpcFlowLogsConfig.AggregationInterval" = proto.Field( + proto.ENUM, + number=4, + optional=True, + enum="VpcFlowLogsConfig.AggregationInterval", + ) + flow_sampling: float = proto.Field( + proto.FLOAT, + number=5, + optional=True, + ) + metadata: "VpcFlowLogsConfig.Metadata" = proto.Field( + proto.ENUM, + number=6, + optional=True, + enum="VpcFlowLogsConfig.Metadata", + ) + metadata_fields: MutableSequence[str] = proto.RepeatedField( + proto.STRING, + number=7, + ) + filter_expr: str = proto.Field( + proto.STRING, + number=8, + optional=True, + ) + cross_project_metadata: "VpcFlowLogsConfig.CrossProjectMetadata" = proto.Field( + proto.ENUM, + number=13, + optional=True, + enum="VpcFlowLogsConfig.CrossProjectMetadata", + ) + network: str = proto.Field( + proto.STRING, + number=100, + oneof="target_resource", + ) + subnet: str = proto.Field( + proto.STRING, + number=101, + oneof="target_resource", + ) + interconnect_attachment: str = proto.Field( + proto.STRING, + number=102, + oneof="target_resource", + ) + vpn_tunnel: str = proto.Field( + proto.STRING, + number=103, + oneof="target_resource", + ) + scope: Scope = proto.Field( + proto.ENUM, + number=12, + optional=True, + enum=Scope, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-cloud-network-management/noxfile.py b/packages/google-cloud-network-management/noxfile.py index 0279b0a48555..214697943dbf 100644 --- a/packages/google-cloud-network-management/noxfile.py +++ b/packages/google-cloud-network-management/noxfile.py @@ -27,6 +27,10 @@ LINT_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"] +# Add samples to the list of directories to format if the directory exists. +if os.path.isdir("samples"): + LINT_PATHS.append("samples") + ALL_PYTHON = [ "3.7", "3.8", diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py new file mode 100644 index 000000000000..5bd2d595cfb2 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 CreateVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_CreateVpcFlowLogsConfig_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 network_management_v1 + + +async def sample_create_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.CreateVpcFlowLogsConfigRequest( + parent="parent_value", + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.create_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = (await operation).result() + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_CreateVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py new file mode 100644 index 000000000000..739c2e08a985 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 CreateVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_CreateVpcFlowLogsConfig_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 network_management_v1 + + +def sample_create_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.CreateVpcFlowLogsConfigRequest( + parent="parent_value", + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.create_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_CreateVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py new file mode 100644 index 000000000000..0e243f099714 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 DeleteVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_DeleteVpcFlowLogsConfig_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 network_management_v1 + + +async def sample_delete_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.DeleteVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = (await operation).result() + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_DeleteVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py new file mode 100644 index 000000000000..d4c5855f3974 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 DeleteVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_DeleteVpcFlowLogsConfig_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 network_management_v1 + + +def sample_delete_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.DeleteVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_DeleteVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py new file mode 100644 index 000000000000..15da3a4843a4 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 GetVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_GetVpcFlowLogsConfig_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 network_management_v1 + + +async def sample_get_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.GetVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + response = await client.get_vpc_flow_logs_config(request=request) + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_GetVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py new file mode 100644 index 000000000000..42875432e339 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 GetVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_GetVpcFlowLogsConfig_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 network_management_v1 + + +def sample_get_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.GetVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Make the request + response = client.get_vpc_flow_logs_config(request=request) + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_GetVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py new file mode 100644 index 000000000000..ea41933f7ef7 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListVpcFlowLogsConfigs +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_ListVpcFlowLogsConfigs_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 network_management_v1 + + +async def sample_list_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.ListVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_vpc_flow_logs_configs(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_ListVpcFlowLogsConfigs_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py new file mode 100644 index 000000000000..daba6cb9e886 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ListVpcFlowLogsConfigs +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_ListVpcFlowLogsConfigs_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 network_management_v1 + + +def sample_list_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.ListVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_vpc_flow_logs_configs(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_ListVpcFlowLogsConfigs_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py new file mode 100644 index 000000000000..255a507ca10b --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 UpdateVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_UpdateVpcFlowLogsConfig_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 network_management_v1 + + +async def sample_update_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.UpdateVpcFlowLogsConfigRequest( + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.update_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = (await operation).result() + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_UpdateVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py new file mode 100644 index 000000000000..1fb03bf14ecb --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 UpdateVpcFlowLogsConfig +# 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-network-management + + +# [START networkmanagement_v1_generated_OrganizationVpcFlowLogsService_UpdateVpcFlowLogsConfig_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 network_management_v1 + + +def sample_update_vpc_flow_logs_config(): + # Create a client + client = network_management_v1.OrganizationVpcFlowLogsServiceClient() + + # Initialize request argument(s) + vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() + vpc_flow_logs_config.network = "network_value" + + request = network_management_v1.UpdateVpcFlowLogsConfigRequest( + vpc_flow_logs_config=vpc_flow_logs_config, + ) + + # Make the request + operation = client.update_vpc_flow_logs_config(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + + +# [END networkmanagement_v1_generated_OrganizationVpcFlowLogsService_UpdateVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py index 4df7bf889bf5..afddac96e32d 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py @@ -54,4 +54,5 @@ async def sample_create_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_CreateConnectivityTest_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py index c3c1865cae19..383ec0c923e6 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py @@ -54,4 +54,5 @@ def sample_create_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_CreateConnectivityTest_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py index 425bf5a2b4bb..fec1cb24e740 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py @@ -53,4 +53,5 @@ async def sample_delete_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_DeleteConnectivityTest_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py index c72b2a506e39..8823d9be5a81 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py @@ -53,4 +53,5 @@ def sample_delete_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_DeleteConnectivityTest_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py index 9ec825051d76..ec4ce6f7950d 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py @@ -49,4 +49,5 @@ async def sample_get_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_GetConnectivityTest_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py index 2c28e17d7f58..a6ae687d17c3 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py @@ -49,4 +49,5 @@ def sample_get_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_GetConnectivityTest_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py index 513f7d442f2b..e6ec98b6795d 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py @@ -50,4 +50,5 @@ async def sample_list_connectivity_tests(): async for response in page_result: print(response) + # [END networkmanagement_v1_generated_ReachabilityService_ListConnectivityTests_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py index ffb070008ca6..c4bc2b597343 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py @@ -50,4 +50,5 @@ def sample_list_connectivity_tests(): for response in page_result: print(response) + # [END networkmanagement_v1_generated_ReachabilityService_ListConnectivityTests_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py index cc3760803a14..055b89f6050e 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py @@ -53,4 +53,5 @@ async def sample_rerun_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_RerunConnectivityTest_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py index 5728379fa7fe..20d0b952a213 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py @@ -53,4 +53,5 @@ def sample_rerun_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_RerunConnectivityTest_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py index 95cedd225a4f..3d01ec601a9c 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py @@ -39,8 +39,7 @@ async def sample_update_connectivity_test(): client = network_management_v1.ReachabilityServiceAsyncClient() # Initialize request argument(s) - request = network_management_v1.UpdateConnectivityTestRequest( - ) + request = network_management_v1.UpdateConnectivityTestRequest() # Make the request operation = client.update_connectivity_test(request=request) @@ -52,4 +51,5 @@ async def sample_update_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_UpdateConnectivityTest_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py index b579e7028b14..b1079ecd4f31 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py @@ -39,8 +39,7 @@ def sample_update_connectivity_test(): client = network_management_v1.ReachabilityServiceClient() # Initialize request argument(s) - request = network_management_v1.UpdateConnectivityTestRequest( - ) + request = network_management_v1.UpdateConnectivityTestRequest() # Make the request operation = client.update_connectivity_test(request=request) @@ -52,4 +51,5 @@ def sample_update_connectivity_test(): # Handle the response print(response) + # [END networkmanagement_v1_generated_ReachabilityService_UpdateConnectivityTest_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py index cf691be8f586..05939cb8f1cd 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py @@ -40,7 +40,7 @@ async def sample_create_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.CreateVpcFlowLogsConfigRequest( parent="parent_value", @@ -58,4 +58,5 @@ async def sample_create_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_CreateVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py index cc83f8b107bf..af643cea112e 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py @@ -40,7 +40,7 @@ def sample_create_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.CreateVpcFlowLogsConfigRequest( parent="parent_value", @@ -58,4 +58,5 @@ def sample_create_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_CreateVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py index b6a508635a6b..cd9397ca0627 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py @@ -53,4 +53,5 @@ async def sample_delete_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_DeleteVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py index b0316ae971ed..067976d22370 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py @@ -53,4 +53,5 @@ def sample_delete_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_DeleteVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py index a81219377c67..4ba45a0450d2 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py @@ -49,4 +49,5 @@ async def sample_get_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_GetVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py index d1f2b918e67b..be4fae89e683 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py @@ -49,4 +49,5 @@ def sample_get_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_GetVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py index 51b5e58ea9a0..f1e652241e5d 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py @@ -50,4 +50,5 @@ async def sample_list_vpc_flow_logs_configs(): async for response in page_result: print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_ListVpcFlowLogsConfigs_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py index 61a8c08ab54b..3d174f08b2f0 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py @@ -50,4 +50,5 @@ def sample_list_vpc_flow_logs_configs(): for response in page_result: print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_ListVpcFlowLogsConfigs_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_async.py new file mode 100644 index 000000000000..5dd464df01d2 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 QueryOrgVpcFlowLogsConfigs +# 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-network-management + + +# [START networkmanagement_v1_generated_VpcFlowLogsService_QueryOrgVpcFlowLogsConfigs_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 network_management_v1 + + +async def sample_query_org_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.QueryOrgVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.query_org_vpc_flow_logs_configs(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END networkmanagement_v1_generated_VpcFlowLogsService_QueryOrgVpcFlowLogsConfigs_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_sync.py new file mode 100644 index 000000000000..483c28ada765 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 QueryOrgVpcFlowLogsConfigs +# 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-network-management + + +# [START networkmanagement_v1_generated_VpcFlowLogsService_QueryOrgVpcFlowLogsConfigs_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 network_management_v1 + + +def sample_query_org_vpc_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.QueryOrgVpcFlowLogsConfigsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.query_org_vpc_flow_logs_configs(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END networkmanagement_v1_generated_VpcFlowLogsService_QueryOrgVpcFlowLogsConfigs_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_async.py new file mode 100644 index 000000000000..2ac3ab255724 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_async.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ShowEffectiveFlowLogsConfigs +# 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-network-management + + +# [START networkmanagement_v1_generated_VpcFlowLogsService_ShowEffectiveFlowLogsConfigs_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 network_management_v1 + + +async def sample_show_effective_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceAsyncClient() + + # Initialize request argument(s) + request = network_management_v1.ShowEffectiveFlowLogsConfigsRequest( + parent="parent_value", + resource="resource_value", + ) + + # Make the request + page_result = client.show_effective_flow_logs_configs(request=request) + + # Handle the response + async for response in page_result: + print(response) + + +# [END networkmanagement_v1_generated_VpcFlowLogsService_ShowEffectiveFlowLogsConfigs_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_sync.py new file mode 100644 index 000000000000..4bd82ed5c0d9 --- /dev/null +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_sync.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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 ShowEffectiveFlowLogsConfigs +# 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-network-management + + +# [START networkmanagement_v1_generated_VpcFlowLogsService_ShowEffectiveFlowLogsConfigs_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 network_management_v1 + + +def sample_show_effective_flow_logs_configs(): + # Create a client + client = network_management_v1.VpcFlowLogsServiceClient() + + # Initialize request argument(s) + request = network_management_v1.ShowEffectiveFlowLogsConfigsRequest( + parent="parent_value", + resource="resource_value", + ) + + # Make the request + page_result = client.show_effective_flow_logs_configs(request=request) + + # Handle the response + for response in page_result: + print(response) + + +# [END networkmanagement_v1_generated_VpcFlowLogsService_ShowEffectiveFlowLogsConfigs_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py index b20bb4028578..5f83e2942c2a 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py @@ -40,7 +40,7 @@ async def sample_update_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.UpdateVpcFlowLogsConfigRequest( vpc_flow_logs_config=vpc_flow_logs_config, @@ -56,4 +56,5 @@ async def sample_update_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_UpdateVpcFlowLogsConfig_async] diff --git a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py index 329a148e1e20..8fe0ef4337b1 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py +++ b/packages/google-cloud-network-management/samples/generated_samples/networkmanagement_v1_generated_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py @@ -40,7 +40,7 @@ def sample_update_vpc_flow_logs_config(): # Initialize request argument(s) vpc_flow_logs_config = network_management_v1.VpcFlowLogsConfig() - vpc_flow_logs_config.interconnect_attachment = "interconnect_attachment_value" + vpc_flow_logs_config.network = "network_value" request = network_management_v1.UpdateVpcFlowLogsConfigRequest( vpc_flow_logs_config=vpc_flow_logs_config, @@ -56,4 +56,5 @@ def sample_update_vpc_flow_logs_config(): # Handle the response print(response) + # [END networkmanagement_v1_generated_VpcFlowLogsService_UpdateVpcFlowLogsConfig_sync] diff --git a/packages/google-cloud-network-management/samples/generated_samples/snippet_metadata_google.cloud.networkmanagement.v1.json b/packages/google-cloud-network-management/samples/generated_samples/snippet_metadata_google.cloud.networkmanagement.v1.json index 3adbef3413c1..22b88eb7162f 100644 --- a/packages/google-cloud-network-management/samples/generated_samples/snippet_metadata_google.cloud.networkmanagement.v1.json +++ b/packages/google-cloud-network-management/samples/generated_samples/snippet_metadata_google.cloud.networkmanagement.v1.json @@ -16,34 +16,34 @@ "clientMethod": { "async": true, "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", - "shortName": "ReachabilityServiceAsyncClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient", + "shortName": "OrganizationVpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.create_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient.create_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.CreateConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.CreateVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "CreateConnectivityTest" + "shortName": "CreateVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.CreateConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest" }, { "name": "parent", "type": "str" }, { - "name": "test_id", - "type": "str" + "name": "vpc_flow_logs_config", + "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" }, { - "name": "resource", - "type": "google.cloud.network_management_v1.types.ConnectivityTest" + "name": "vpc_flow_logs_config_id", + "type": "str" }, { "name": "retry", @@ -59,21 +59,21 @@ } ], "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "create_connectivity_test" + "shortName": "create_vpc_flow_logs_config" }, - "description": "Sample for CreateConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py", + "description": "Sample for CreateVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_CreateConnectivityTest_async", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_CreateVpcFlowLogsConfig_async", "segments": [ { - "end": 56, + "end": 60, "start": 27, "type": "FULL" }, { - "end": 56, + "end": 60, "start": 27, "type": "SHORT" }, @@ -83,55 +83,55 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 46, + "end": 50, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 53, - "start": 47, + "end": 57, + "start": 51, "type": "REQUEST_EXECUTION" }, { - "end": 57, - "start": 54, + "end": 61, + "start": 58, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py" }, { "canonical": true, "clientMethod": { "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", - "shortName": "ReachabilityServiceClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient", + "shortName": "OrganizationVpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.create_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient.create_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.CreateConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.CreateVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "CreateConnectivityTest" + "shortName": "CreateVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.CreateConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest" }, { "name": "parent", "type": "str" }, { - "name": "test_id", - "type": "str" + "name": "vpc_flow_logs_config", + "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" }, { - "name": "resource", - "type": "google.cloud.network_management_v1.types.ConnectivityTest" + "name": "vpc_flow_logs_config_id", + "type": "str" }, { "name": "retry", @@ -147,21 +147,21 @@ } ], "resultType": "google.api_core.operation.Operation", - "shortName": "create_connectivity_test" + "shortName": "create_vpc_flow_logs_config" }, - "description": "Sample for CreateConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py", + "description": "Sample for CreateVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_CreateConnectivityTest_sync", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_CreateVpcFlowLogsConfig_sync", "segments": [ { - "end": 56, + "end": 60, "start": 27, "type": "FULL" }, { - "end": 56, + "end": 60, "start": 27, "type": "SHORT" }, @@ -171,44 +171,44 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 46, + "end": 50, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 53, - "start": 47, + "end": 57, + "start": 51, "type": "REQUEST_EXECUTION" }, { - "end": 57, - "start": 54, + "end": 61, + "start": 58, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py" }, { "canonical": true, "clientMethod": { "async": true, "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", - "shortName": "ReachabilityServiceAsyncClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient", + "shortName": "OrganizationVpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.delete_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient.delete_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.DeleteConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.DeleteVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "DeleteConnectivityTest" + "shortName": "DeleteVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.DeleteConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest" }, { "name": "name", @@ -228,13 +228,13 @@ } ], "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "delete_connectivity_test" + "shortName": "delete_vpc_flow_logs_config" }, - "description": "Sample for DeleteConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py", + "description": "Sample for DeleteVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_DeleteConnectivityTest_async", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_DeleteVpcFlowLogsConfig_async", "segments": [ { "end": 55, @@ -267,28 +267,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py" }, { "canonical": true, "clientMethod": { "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", - "shortName": "ReachabilityServiceClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient", + "shortName": "OrganizationVpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.delete_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient.delete_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.DeleteConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.DeleteVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "DeleteConnectivityTest" + "shortName": "DeleteVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.DeleteConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest" }, { "name": "name", @@ -308,13 +308,13 @@ } ], "resultType": "google.api_core.operation.Operation", - "shortName": "delete_connectivity_test" + "shortName": "delete_vpc_flow_logs_config" }, - "description": "Sample for DeleteConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py", + "description": "Sample for DeleteVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_DeleteConnectivityTest_sync", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_DeleteVpcFlowLogsConfig_sync", "segments": [ { "end": 55, @@ -347,29 +347,29 @@ "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py" }, { "canonical": true, "clientMethod": { "async": true, "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", - "shortName": "ReachabilityServiceAsyncClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient", + "shortName": "OrganizationVpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.get_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient.get_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.GetConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.GetVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "GetConnectivityTest" + "shortName": "GetVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.GetConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest" }, { "name": "name", @@ -388,14 +388,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.types.ConnectivityTest", - "shortName": "get_connectivity_test" + "resultType": "google.cloud.network_management_v1.types.VpcFlowLogsConfig", + "shortName": "get_vpc_flow_logs_config" }, - "description": "Sample for GetConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py", + "description": "Sample for GetVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_GetConnectivityTest_async", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_GetVpcFlowLogsConfig_async", "segments": [ { "end": 51, @@ -428,28 +428,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py" }, { "canonical": true, "clientMethod": { "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", - "shortName": "ReachabilityServiceClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient", + "shortName": "OrganizationVpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.get_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient.get_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.GetConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.GetVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "GetConnectivityTest" + "shortName": "GetVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.GetConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest" }, { "name": "name", @@ -468,14 +468,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.types.ConnectivityTest", - "shortName": "get_connectivity_test" + "resultType": "google.cloud.network_management_v1.types.VpcFlowLogsConfig", + "shortName": "get_vpc_flow_logs_config" }, - "description": "Sample for GetConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py", + "description": "Sample for GetVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_GetConnectivityTest_sync", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_GetVpcFlowLogsConfig_sync", "segments": [ { "end": 51, @@ -508,29 +508,29 @@ "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py" }, { "canonical": true, "clientMethod": { "async": true, "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", - "shortName": "ReachabilityServiceAsyncClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient", + "shortName": "OrganizationVpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.list_connectivity_tests", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient.list_vpc_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.ListConnectivityTests", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.ListVpcFlowLogsConfigs", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "ListConnectivityTests" + "shortName": "ListVpcFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.ListConnectivityTestsRequest" + "type": "google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest" }, { "name": "parent", @@ -549,14 +549,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.services.reachability_service.pagers.ListConnectivityTestsAsyncPager", - "shortName": "list_connectivity_tests" + "resultType": "google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsAsyncPager", + "shortName": "list_vpc_flow_logs_configs" }, - "description": "Sample for ListConnectivityTests", - "file": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py", + "description": "Sample for ListVpcFlowLogsConfigs", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_ListConnectivityTests_async", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_ListVpcFlowLogsConfigs_async", "segments": [ { "end": 52, @@ -589,28 +589,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py" }, { "canonical": true, "clientMethod": { "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", - "shortName": "ReachabilityServiceClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient", + "shortName": "OrganizationVpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.list_connectivity_tests", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient.list_vpc_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.ListConnectivityTests", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.ListVpcFlowLogsConfigs", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "ListConnectivityTests" + "shortName": "ListVpcFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.ListConnectivityTestsRequest" + "type": "google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest" }, { "name": "parent", @@ -629,14 +629,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.services.reachability_service.pagers.ListConnectivityTestsPager", - "shortName": "list_connectivity_tests" + "resultType": "google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsPager", + "shortName": "list_vpc_flow_logs_configs" }, - "description": "Sample for ListConnectivityTests", - "file": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py", + "description": "Sample for ListVpcFlowLogsConfigs", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_ListConnectivityTests_sync", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_ListVpcFlowLogsConfigs_sync", "segments": [ { "end": 52, @@ -669,29 +669,37 @@ "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py" }, { "canonical": true, "clientMethod": { "async": true, "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", - "shortName": "ReachabilityServiceAsyncClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient", + "shortName": "OrganizationVpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.rerun_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceAsyncClient.update_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.RerunConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.UpdateVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "RerunConnectivityTest" + "shortName": "UpdateVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.RerunConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.UpdateVpcFlowLogsConfigRequest" + }, + { + "name": "vpc_flow_logs_config", + "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" }, { "name": "retry", @@ -707,21 +715,21 @@ } ], "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "rerun_connectivity_test" + "shortName": "update_vpc_flow_logs_config" }, - "description": "Sample for RerunConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py", + "description": "Sample for UpdateVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_RerunConnectivityTest_async", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_UpdateVpcFlowLogsConfig_async", "segments": [ { - "end": 55, + "end": 58, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 58, "start": 27, "type": "SHORT" }, @@ -731,43 +739,51 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 48, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 52, - "start": 46, + "end": 55, + "start": 49, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 59, + "start": 56, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_async.py" }, { "canonical": true, "clientMethod": { "client": { - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", - "shortName": "ReachabilityServiceClient" + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient", + "shortName": "OrganizationVpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.rerun_connectivity_test", + "fullName": "google.cloud.network_management_v1.OrganizationVpcFlowLogsServiceClient.update_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.RerunConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService.UpdateVpcFlowLogsConfig", "service": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", - "shortName": "ReachabilityService" + "fullName": "google.cloud.networkmanagement.v1.OrganizationVpcFlowLogsService", + "shortName": "OrganizationVpcFlowLogsService" }, - "shortName": "RerunConnectivityTest" + "shortName": "UpdateVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.RerunConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.UpdateVpcFlowLogsConfigRequest" + }, + { + "name": "vpc_flow_logs_config", + "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" }, { "name": "retry", @@ -783,21 +799,21 @@ } ], "resultType": "google.api_core.operation.Operation", - "shortName": "rerun_connectivity_test" + "shortName": "update_vpc_flow_logs_config" }, - "description": "Sample for RerunConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py", + "description": "Sample for UpdateVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_RerunConnectivityTest_sync", + "regionTag": "networkmanagement_v1_generated_OrganizationVpcFlowLogsService_UpdateVpcFlowLogsConfig_sync", "segments": [ { - "end": 55, + "end": 58, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 58, "start": 27, "type": "SHORT" }, @@ -807,22 +823,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 48, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 52, - "start": 46, + "end": 55, + "start": 49, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 59, + "start": 56, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py" + "title": "networkmanagement_v1_generated_organization_vpc_flow_logs_service_update_vpc_flow_logs_config_sync.py" }, { "canonical": true, @@ -832,23 +848,27 @@ "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", "shortName": "ReachabilityServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.update_connectivity_test", + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.create_connectivity_test", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.UpdateConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.CreateConnectivityTest", "service": { "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", "shortName": "ReachabilityService" }, - "shortName": "UpdateConnectivityTest" + "shortName": "CreateConnectivityTest" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.UpdateConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.CreateConnectivityTestRequest" }, { - "name": "update_mask", - "type": "google.protobuf.field_mask_pb2.FieldMask" + "name": "parent", + "type": "str" + }, + { + "name": "test_id", + "type": "str" }, { "name": "resource", @@ -868,21 +888,21 @@ } ], "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "update_connectivity_test" + "shortName": "create_connectivity_test" }, - "description": "Sample for UpdateConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py", + "description": "Sample for CreateConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_UpdateConnectivityTest_async", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_CreateConnectivityTest_async", "segments": [ { - "end": 54, + "end": 56, "start": 27, "type": "FULL" }, { - "end": 54, + "end": 56, "start": 27, "type": "SHORT" }, @@ -892,22 +912,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 44, + "end": 46, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 51, - "start": 45, + "end": 53, + "start": 47, "type": "REQUEST_EXECUTION" }, { - "end": 55, - "start": 52, + "end": 57, + "start": 54, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py" + "title": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_async.py" }, { "canonical": true, @@ -916,23 +936,27 @@ "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", "shortName": "ReachabilityServiceClient" }, - "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.update_connectivity_test", + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.create_connectivity_test", "method": { - "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.UpdateConnectivityTest", + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.CreateConnectivityTest", "service": { "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", "shortName": "ReachabilityService" }, - "shortName": "UpdateConnectivityTest" + "shortName": "CreateConnectivityTest" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.UpdateConnectivityTestRequest" + "type": "google.cloud.network_management_v1.types.CreateConnectivityTestRequest" }, { - "name": "update_mask", - "type": "google.protobuf.field_mask_pb2.FieldMask" + "name": "parent", + "type": "str" + }, + { + "name": "test_id", + "type": "str" }, { "name": "resource", @@ -952,21 +976,1164 @@ } ], "resultType": "google.api_core.operation.Operation", - "shortName": "update_connectivity_test" + "shortName": "create_connectivity_test" }, - "description": "Sample for UpdateConnectivityTest", - "file": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py", + "description": "Sample for CreateConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_ReachabilityService_UpdateConnectivityTest_sync", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_CreateConnectivityTest_sync", "segments": [ { - "end": 54, + "end": 56, "start": 27, "type": "FULL" }, { - "end": 54, + "end": 56, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 53, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 57, + "start": 54, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_create_connectivity_test_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", + "shortName": "ReachabilityServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.delete_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.DeleteConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "DeleteConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.DeleteConnectivityTestRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "delete_connectivity_test" + }, + "description": "Sample for DeleteConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_DeleteConnectivityTest_async", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", + "shortName": "ReachabilityServiceClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.delete_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.DeleteConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "DeleteConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.DeleteConnectivityTestRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_connectivity_test" + }, + "description": "Sample for DeleteConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_DeleteConnectivityTest_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_delete_connectivity_test_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", + "shortName": "ReachabilityServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.get_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.GetConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "GetConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.GetConnectivityTestRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.network_management_v1.types.ConnectivityTest", + "shortName": "get_connectivity_test" + }, + "description": "Sample for GetConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_GetConnectivityTest_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", + "shortName": "ReachabilityServiceClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.get_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.GetConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "GetConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.GetConnectivityTestRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.network_management_v1.types.ConnectivityTest", + "shortName": "get_connectivity_test" + }, + "description": "Sample for GetConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_GetConnectivityTest_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_get_connectivity_test_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", + "shortName": "ReachabilityServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.list_connectivity_tests", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.ListConnectivityTests", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "ListConnectivityTests" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.ListConnectivityTestsRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.network_management_v1.services.reachability_service.pagers.ListConnectivityTestsAsyncPager", + "shortName": "list_connectivity_tests" + }, + "description": "Sample for ListConnectivityTests", + "file": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_ListConnectivityTests_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", + "shortName": "ReachabilityServiceClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.list_connectivity_tests", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.ListConnectivityTests", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "ListConnectivityTests" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.ListConnectivityTestsRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.network_management_v1.services.reachability_service.pagers.ListConnectivityTestsPager", + "shortName": "list_connectivity_tests" + }, + "description": "Sample for ListConnectivityTests", + "file": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_ListConnectivityTests_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_list_connectivity_tests_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", + "shortName": "ReachabilityServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.rerun_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.RerunConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "RerunConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.RerunConnectivityTestRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "rerun_connectivity_test" + }, + "description": "Sample for RerunConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_RerunConnectivityTest_async", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", + "shortName": "ReachabilityServiceClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.rerun_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.RerunConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "RerunConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.RerunConnectivityTestRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "rerun_connectivity_test" + }, + "description": "Sample for RerunConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_RerunConnectivityTest_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_rerun_connectivity_test_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient", + "shortName": "ReachabilityServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceAsyncClient.update_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.UpdateConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "UpdateConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.UpdateConnectivityTestRequest" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" + }, + { + "name": "resource", + "type": "google.cloud.network_management_v1.types.ConnectivityTest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "update_connectivity_test" + }, + "description": "Sample for UpdateConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_UpdateConnectivityTest_async", + "segments": [ + { + "end": 54, + "start": 27, + "type": "FULL" + }, + { + "end": 54, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 51, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 55, + "start": 52, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient", + "shortName": "ReachabilityServiceClient" + }, + "fullName": "google.cloud.network_management_v1.ReachabilityServiceClient.update_connectivity_test", + "method": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService.UpdateConnectivityTest", + "service": { + "fullName": "google.cloud.networkmanagement.v1.ReachabilityService", + "shortName": "ReachabilityService" + }, + "shortName": "UpdateConnectivityTest" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.UpdateConnectivityTestRequest" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" + }, + { + "name": "resource", + "type": "google.cloud.network_management_v1.types.ConnectivityTest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "update_connectivity_test" + }, + "description": "Sample for UpdateConnectivityTest", + "file": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_ReachabilityService_UpdateConnectivityTest_sync", + "segments": [ + { + "end": 54, + "start": 27, + "type": "FULL" + }, + { + "end": 54, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 51, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 55, + "start": 52, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient", + "shortName": "VpcFlowLogsServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.create_vpc_flow_logs_config", + "method": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.CreateVpcFlowLogsConfig", + "service": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "shortName": "VpcFlowLogsService" + }, + "shortName": "CreateVpcFlowLogsConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "vpc_flow_logs_config", + "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" + }, + { + "name": "vpc_flow_logs_config_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "create_vpc_flow_logs_config" + }, + "description": "Sample for CreateVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_CreateVpcFlowLogsConfig_async", + "segments": [ + { + "end": 60, + "start": 27, + "type": "FULL" + }, + { + "end": 60, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 50, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 57, + "start": 51, + "type": "REQUEST_EXECUTION" + }, + { + "end": 61, + "start": 58, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient", + "shortName": "VpcFlowLogsServiceClient" + }, + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.create_vpc_flow_logs_config", + "method": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.CreateVpcFlowLogsConfig", + "service": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "shortName": "VpcFlowLogsService" + }, + "shortName": "CreateVpcFlowLogsConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "vpc_flow_logs_config", + "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" + }, + { + "name": "vpc_flow_logs_config_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "create_vpc_flow_logs_config" + }, + "description": "Sample for CreateVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_CreateVpcFlowLogsConfig_sync", + "segments": [ + { + "end": 60, + "start": 27, + "type": "FULL" + }, + { + "end": 60, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 50, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 57, + "start": 51, + "type": "REQUEST_EXECUTION" + }, + { + "end": 61, + "start": 58, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient", + "shortName": "VpcFlowLogsServiceAsyncClient" + }, + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.delete_vpc_flow_logs_config", + "method": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.DeleteVpcFlowLogsConfig", + "service": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "shortName": "VpcFlowLogsService" + }, + "shortName": "DeleteVpcFlowLogsConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "delete_vpc_flow_logs_config" + }, + "description": "Sample for DeleteVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_DeleteVpcFlowLogsConfig_async", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient", + "shortName": "VpcFlowLogsServiceClient" + }, + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.delete_vpc_flow_logs_config", + "method": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.DeleteVpcFlowLogsConfig", + "service": { + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", + "shortName": "VpcFlowLogsService" + }, + "shortName": "DeleteVpcFlowLogsConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_vpc_flow_logs_config" + }, + "description": "Sample for DeleteVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_DeleteVpcFlowLogsConfig_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, "start": 27, "type": "SHORT" }, @@ -976,22 +2143,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 44, + "end": 45, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 51, - "start": 45, + "end": 52, + "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 55, - "start": 52, + "end": 56, + "start": 53, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_reachability_service_update_connectivity_test_sync.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py" }, { "canonical": true, @@ -1001,30 +2168,22 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient", "shortName": "VpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.create_vpc_flow_logs_config", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.get_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.CreateVpcFlowLogsConfig", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.GetVpcFlowLogsConfig", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "CreateVpcFlowLogsConfig" + "shortName": "GetVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest" - }, - { - "name": "parent", - "type": "str" - }, - { - "name": "vpc_flow_logs_config", - "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" + "type": "google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest" }, { - "name": "vpc_flow_logs_config_id", + "name": "name", "type": "str" }, { @@ -1040,22 +2199,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "create_vpc_flow_logs_config" + "resultType": "google.cloud.network_management_v1.types.VpcFlowLogsConfig", + "shortName": "get_vpc_flow_logs_config" }, - "description": "Sample for CreateVpcFlowLogsConfig", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py", + "description": "Sample for GetVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_CreateVpcFlowLogsConfig_async", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_GetVpcFlowLogsConfig_async", "segments": [ { - "end": 60, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 60, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1065,22 +2224,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 50, + "end": 45, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 57, - "start": 51, + "end": 48, + "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 61, - "start": 58, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_async.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py" }, { "canonical": true, @@ -1089,30 +2248,22 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient", "shortName": "VpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.create_vpc_flow_logs_config", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.get_vpc_flow_logs_config", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.CreateVpcFlowLogsConfig", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.GetVpcFlowLogsConfig", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "CreateVpcFlowLogsConfig" + "shortName": "GetVpcFlowLogsConfig" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.CreateVpcFlowLogsConfigRequest" - }, - { - "name": "parent", - "type": "str" - }, - { - "name": "vpc_flow_logs_config", - "type": "google.cloud.network_management_v1.types.VpcFlowLogsConfig" + "type": "google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest" }, { - "name": "vpc_flow_logs_config_id", + "name": "name", "type": "str" }, { @@ -1128,22 +2279,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "create_vpc_flow_logs_config" + "resultType": "google.cloud.network_management_v1.types.VpcFlowLogsConfig", + "shortName": "get_vpc_flow_logs_config" }, - "description": "Sample for CreateVpcFlowLogsConfig", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py", + "description": "Sample for GetVpcFlowLogsConfig", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_CreateVpcFlowLogsConfig_sync", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_GetVpcFlowLogsConfig_sync", "segments": [ { - "end": 60, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 60, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1153,22 +2304,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 50, + "end": 45, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 57, - "start": 51, + "end": 48, + "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 61, - "start": 58, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_create_vpc_flow_logs_config_sync.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py" }, { "canonical": true, @@ -1178,22 +2329,22 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient", "shortName": "VpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.delete_vpc_flow_logs_config", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.list_vpc_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.DeleteVpcFlowLogsConfig", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.ListVpcFlowLogsConfigs", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "DeleteVpcFlowLogsConfig" + "shortName": "ListVpcFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest" + "type": "google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1209,22 +2360,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "delete_vpc_flow_logs_config" + "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsAsyncPager", + "shortName": "list_vpc_flow_logs_configs" }, - "description": "Sample for DeleteVpcFlowLogsConfig", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py", + "description": "Sample for ListVpcFlowLogsConfigs", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_DeleteVpcFlowLogsConfig_async", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_ListVpcFlowLogsConfigs_async", "segments": [ { - "end": 55, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1239,17 +2390,17 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 53, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_async.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py" }, { "canonical": true, @@ -1258,22 +2409,22 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient", "shortName": "VpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.delete_vpc_flow_logs_config", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.list_vpc_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.DeleteVpcFlowLogsConfig", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.ListVpcFlowLogsConfigs", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "DeleteVpcFlowLogsConfig" + "shortName": "ListVpcFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.DeleteVpcFlowLogsConfigRequest" + "type": "google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1289,22 +2440,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "delete_vpc_flow_logs_config" + "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsPager", + "shortName": "list_vpc_flow_logs_configs" }, - "description": "Sample for DeleteVpcFlowLogsConfig", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py", + "description": "Sample for ListVpcFlowLogsConfigs", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_DeleteVpcFlowLogsConfig_sync", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_ListVpcFlowLogsConfigs_sync", "segments": [ { - "end": 55, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1319,17 +2470,17 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 53, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_delete_vpc_flow_logs_config_sync.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py" }, { "canonical": true, @@ -1339,23 +2490,19 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient", "shortName": "VpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.get_vpc_flow_logs_config", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.query_org_vpc_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.GetVpcFlowLogsConfig", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.QueryOrgVpcFlowLogsConfigs", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "GetVpcFlowLogsConfig" + "shortName": "QueryOrgVpcFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest" - }, - { - "name": "name", - "type": "str" + "type": "google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsRequest" }, { "name": "retry", @@ -1370,22 +2517,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.types.VpcFlowLogsConfig", - "shortName": "get_vpc_flow_logs_config" + "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.QueryOrgVpcFlowLogsConfigsAsyncPager", + "shortName": "query_org_vpc_flow_logs_configs" }, - "description": "Sample for GetVpcFlowLogsConfig", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py", + "description": "Sample for QueryOrgVpcFlowLogsConfigs", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_GetVpcFlowLogsConfig_async", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_QueryOrgVpcFlowLogsConfigs_async", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1405,12 +2552,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_async.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_async.py" }, { "canonical": true, @@ -1419,23 +2566,19 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient", "shortName": "VpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.get_vpc_flow_logs_config", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.query_org_vpc_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.GetVpcFlowLogsConfig", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.QueryOrgVpcFlowLogsConfigs", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "GetVpcFlowLogsConfig" + "shortName": "QueryOrgVpcFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.GetVpcFlowLogsConfigRequest" - }, - { - "name": "name", - "type": "str" + "type": "google.cloud.network_management_v1.types.QueryOrgVpcFlowLogsConfigsRequest" }, { "name": "retry", @@ -1450,22 +2593,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.types.VpcFlowLogsConfig", - "shortName": "get_vpc_flow_logs_config" + "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.QueryOrgVpcFlowLogsConfigsPager", + "shortName": "query_org_vpc_flow_logs_configs" }, - "description": "Sample for GetVpcFlowLogsConfig", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py", + "description": "Sample for QueryOrgVpcFlowLogsConfigs", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_GetVpcFlowLogsConfig_sync", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_QueryOrgVpcFlowLogsConfigs_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1485,12 +2628,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_get_vpc_flow_logs_config_sync.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_query_org_vpc_flow_logs_configs_sync.py" }, { "canonical": true, @@ -1500,23 +2643,19 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient", "shortName": "VpcFlowLogsServiceAsyncClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.list_vpc_flow_logs_configs", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceAsyncClient.show_effective_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.ListVpcFlowLogsConfigs", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.ShowEffectiveFlowLogsConfigs", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "ListVpcFlowLogsConfigs" + "shortName": "ShowEffectiveFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest" - }, - { - "name": "parent", - "type": "str" + "type": "google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsRequest" }, { "name": "retry", @@ -1531,22 +2670,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsAsyncPager", - "shortName": "list_vpc_flow_logs_configs" + "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ShowEffectiveFlowLogsConfigsAsyncPager", + "shortName": "show_effective_flow_logs_configs" }, - "description": "Sample for ListVpcFlowLogsConfigs", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py", + "description": "Sample for ShowEffectiveFlowLogsConfigs", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_ListVpcFlowLogsConfigs_async", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_ShowEffectiveFlowLogsConfigs_async", "segments": [ { - "end": 52, + "end": 53, "start": 27, "type": "FULL" }, { - "end": 52, + "end": 53, "start": 27, "type": "SHORT" }, @@ -1556,22 +2695,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 46, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 48, - "start": 46, + "end": 49, + "start": 47, "type": "REQUEST_EXECUTION" }, { - "end": 53, - "start": 49, + "end": 54, + "start": 50, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_async.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_async.py" }, { "canonical": true, @@ -1580,23 +2719,19 @@ "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient", "shortName": "VpcFlowLogsServiceClient" }, - "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.list_vpc_flow_logs_configs", + "fullName": "google.cloud.network_management_v1.VpcFlowLogsServiceClient.show_effective_flow_logs_configs", "method": { - "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.ListVpcFlowLogsConfigs", + "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService.ShowEffectiveFlowLogsConfigs", "service": { "fullName": "google.cloud.networkmanagement.v1.VpcFlowLogsService", "shortName": "VpcFlowLogsService" }, - "shortName": "ListVpcFlowLogsConfigs" + "shortName": "ShowEffectiveFlowLogsConfigs" }, "parameters": [ { "name": "request", - "type": "google.cloud.network_management_v1.types.ListVpcFlowLogsConfigsRequest" - }, - { - "name": "parent", - "type": "str" + "type": "google.cloud.network_management_v1.types.ShowEffectiveFlowLogsConfigsRequest" }, { "name": "retry", @@ -1611,22 +2746,22 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ListVpcFlowLogsConfigsPager", - "shortName": "list_vpc_flow_logs_configs" + "resultType": "google.cloud.network_management_v1.services.vpc_flow_logs_service.pagers.ShowEffectiveFlowLogsConfigsPager", + "shortName": "show_effective_flow_logs_configs" }, - "description": "Sample for ListVpcFlowLogsConfigs", - "file": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py", + "description": "Sample for ShowEffectiveFlowLogsConfigs", + "file": "networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_ListVpcFlowLogsConfigs_sync", + "regionTag": "networkmanagement_v1_generated_VpcFlowLogsService_ShowEffectiveFlowLogsConfigs_sync", "segments": [ { - "end": 52, + "end": 53, "start": 27, "type": "FULL" }, { - "end": 52, + "end": 53, "start": 27, "type": "SHORT" }, @@ -1636,22 +2771,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 46, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 48, - "start": 46, + "end": 49, + "start": 47, "type": "REQUEST_EXECUTION" }, { - "end": 53, - "start": 49, + "end": 54, + "start": 50, "type": "RESPONSE_HANDLING" } ], - "title": "networkmanagement_v1_generated_vpc_flow_logs_service_list_vpc_flow_logs_configs_sync.py" + "title": "networkmanagement_v1_generated_vpc_flow_logs_service_show_effective_flow_logs_configs_sync.py" }, { "canonical": true, diff --git a/packages/google-cloud-network-management/scripts/fixup_network_management_v1_keywords.py b/packages/google-cloud-network-management/scripts/fixup_network_management_v1_keywords.py index d0bbd52255f3..4883cedc4e17 100644 --- a/packages/google-cloud-network-management/scripts/fixup_network_management_v1_keywords.py +++ b/packages/google-cloud-network-management/scripts/fixup_network_management_v1_keywords.py @@ -47,7 +47,9 @@ class network_managementCallTransformer(cst.CSTTransformer): 'get_vpc_flow_logs_config': ('name', ), 'list_connectivity_tests': ('parent', 'page_size', 'page_token', 'filter', 'order_by', ), 'list_vpc_flow_logs_configs': ('parent', 'page_size', 'page_token', 'filter', 'order_by', ), + 'query_org_vpc_flow_logs_configs': ('parent', 'page_size', 'page_token', 'filter', ), 'rerun_connectivity_test': ('name', ), + 'show_effective_flow_logs_configs': ('parent', 'resource', 'page_size', 'page_token', 'filter', ), 'update_connectivity_test': ('update_mask', 'resource', ), 'update_vpc_flow_logs_config': ('update_mask', 'vpc_flow_logs_config', ), } diff --git a/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_organization_vpc_flow_logs_service.py b/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_organization_vpc_flow_logs_service.py new file mode 100644 index 000000000000..87890c79b4f9 --- /dev/null +++ b/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_organization_vpc_flow_logs_service.py @@ -0,0 +1,8406 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 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. +# +import os + +# try/except added for compatibility with python < 3.8 +try: + from unittest import mock + from unittest.mock import AsyncMock # pragma: NO COVER +except ImportError: # pragma: NO COVER + import mock + +from collections.abc import AsyncIterable, Iterable +import json +import math + +from google.api_core import api_core_version +from google.protobuf import json_format +import grpc +from grpc.experimental import aio +from proto.marshal.rules import wrappers +from proto.marshal.rules.dates import DurationRule, TimestampRule +import pytest +from requests import PreparedRequest, Request, Response +from requests.sessions import Session + +try: + from google.auth.aio import credentials as ga_credentials_async + + HAS_GOOGLE_AUTH_AIO = True +except ImportError: # pragma: NO COVER + HAS_GOOGLE_AUTH_AIO = False + +from google.api_core import ( + future, + gapic_v1, + grpc_helpers, + grpc_helpers_async, + operation, + operations_v1, + path_template, +) +from google.api_core import client_options +from google.api_core import exceptions as core_exceptions +from google.api_core import operation_async # type: ignore +from google.api_core import retry as retries +import google.auth +from google.auth import credentials as ga_credentials +from google.auth.exceptions import MutualTLSChannelError +from google.cloud.location import locations_pb2 +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import options_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore +from google.longrunning import operations_pb2 # type: ignore +from google.oauth2 import service_account +from google.protobuf import empty_pb2 # type: ignore +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore + +from google.cloud.network_management_v1.services.organization_vpc_flow_logs_service import ( + OrganizationVpcFlowLogsServiceAsyncClient, + OrganizationVpcFlowLogsServiceClient, + pagers, + transports, +) +from google.cloud.network_management_v1.types import reachability, vpc_flow_logs +from google.cloud.network_management_v1.types import ( + vpc_flow_logs_config as gcn_vpc_flow_logs_config, +) +from google.cloud.network_management_v1.types import vpc_flow_logs_config + +CRED_INFO_JSON = { + "credential_source": "/path/to/file", + "credential_type": "service account credentials", + "principal": "service-account@example.com", +} +CRED_INFO_STRING = json.dumps(CRED_INFO_JSON) + + +async def mock_async_gen(data, chunk_size=1): + for i in range(0, len(data)): # pragma: NO COVER + chunk = data[i : i + chunk_size] + yield chunk.encode("utf-8") + + +def client_cert_source_callback(): + return b"cert bytes", b"key bytes" + + +# TODO: use async auth anon credentials by default once the minimum version of google-auth is upgraded. +# See related issue: https://github.com/googleapis/gapic-generator-python/issues/2107. +def async_anonymous_credentials(): + if HAS_GOOGLE_AUTH_AIO: + return ga_credentials_async.AnonymousCredentials() + return ga_credentials.AnonymousCredentials() + + +# If default endpoint is localhost, then default mtls endpoint will be the same. +# This method modifies the default endpoint so the client can produce a different +# mtls endpoint for endpoint testing purposes. +def modify_default_endpoint(client): + return ( + "foo.googleapis.com" + if ("localhost" in client.DEFAULT_ENDPOINT) + else client.DEFAULT_ENDPOINT + ) + + +# If default endpoint template is localhost, then default mtls endpoint will be the same. +# This method modifies the default endpoint template so the client can produce a different +# mtls endpoint for endpoint testing purposes. +def modify_default_endpoint_template(client): + return ( + "test.{UNIVERSE_DOMAIN}" + if ("localhost" in client._DEFAULT_ENDPOINT_TEMPLATE) + else client._DEFAULT_ENDPOINT_TEMPLATE + ) + + +def test__get_default_mtls_endpoint(): + api_endpoint = "example.googleapis.com" + api_mtls_endpoint = "example.mtls.googleapis.com" + sandbox_endpoint = "example.sandbox.googleapis.com" + sandbox_mtls_endpoint = "example.mtls.sandbox.googleapis.com" + non_googleapi = "api.example.com" + + assert OrganizationVpcFlowLogsServiceClient._get_default_mtls_endpoint(None) is None + assert ( + OrganizationVpcFlowLogsServiceClient._get_default_mtls_endpoint(api_endpoint) + == api_mtls_endpoint + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_default_mtls_endpoint( + api_mtls_endpoint + ) + == api_mtls_endpoint + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_default_mtls_endpoint( + sandbox_endpoint + ) + == sandbox_mtls_endpoint + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_default_mtls_endpoint( + sandbox_mtls_endpoint + ) + == sandbox_mtls_endpoint + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_default_mtls_endpoint(non_googleapi) + == non_googleapi + ) + + +def test__read_environment_variables(): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + False, + "auto", + None, + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + True, + "auto", + None, + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + False, + "auto", + None, + ) + + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError) as excinfo: + OrganizationVpcFlowLogsServiceClient._read_environment_variables() + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + False, + "never", + None, + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + False, + "always", + None, + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"}): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + False, + "auto", + None, + ) + + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError) as excinfo: + OrganizationVpcFlowLogsServiceClient._read_environment_variables() + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + with mock.patch.dict(os.environ, {"GOOGLE_CLOUD_UNIVERSE_DOMAIN": "foo.com"}): + assert OrganizationVpcFlowLogsServiceClient._read_environment_variables() == ( + False, + "auto", + "foo.com", + ) + + +def test__get_client_cert_source(): + mock_provided_cert_source = mock.Mock() + mock_default_cert_source = mock.Mock() + + assert ( + OrganizationVpcFlowLogsServiceClient._get_client_cert_source(None, False) + is None + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_client_cert_source( + mock_provided_cert_source, False + ) + is None + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_client_cert_source( + mock_provided_cert_source, True + ) + == mock_provided_cert_source + ) + + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", return_value=True + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=mock_default_cert_source, + ): + assert ( + OrganizationVpcFlowLogsServiceClient._get_client_cert_source(None, True) + is mock_default_cert_source + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_client_cert_source( + mock_provided_cert_source, "true" + ) + is mock_provided_cert_source + ) + + +@mock.patch.object( + OrganizationVpcFlowLogsServiceClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceClient), +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceAsyncClient), +) +def test__get_api_endpoint(): + api_override = "foo.com" + mock_client_cert_source = mock.Mock() + default_universe = OrganizationVpcFlowLogsServiceClient._DEFAULT_UNIVERSE + default_endpoint = ( + OrganizationVpcFlowLogsServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=default_universe + ) + ) + mock_universe = "bar.com" + mock_endpoint = ( + OrganizationVpcFlowLogsServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=mock_universe + ) + ) + + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + api_override, mock_client_cert_source, default_universe, "always" + ) + == api_override + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, mock_client_cert_source, default_universe, "auto" + ) + == OrganizationVpcFlowLogsServiceClient.DEFAULT_MTLS_ENDPOINT + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, None, default_universe, "auto" + ) + == default_endpoint + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, None, default_universe, "always" + ) + == OrganizationVpcFlowLogsServiceClient.DEFAULT_MTLS_ENDPOINT + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, mock_client_cert_source, default_universe, "always" + ) + == OrganizationVpcFlowLogsServiceClient.DEFAULT_MTLS_ENDPOINT + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, None, mock_universe, "never" + ) + == mock_endpoint + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, None, default_universe, "never" + ) + == default_endpoint + ) + + with pytest.raises(MutualTLSChannelError) as excinfo: + OrganizationVpcFlowLogsServiceClient._get_api_endpoint( + None, mock_client_cert_source, mock_universe, "auto" + ) + assert ( + str(excinfo.value) + == "mTLS is not supported in any universe other than googleapis.com." + ) + + +def test__get_universe_domain(): + client_universe_domain = "foo.com" + universe_domain_env = "bar.com" + + assert ( + OrganizationVpcFlowLogsServiceClient._get_universe_domain( + client_universe_domain, universe_domain_env + ) + == client_universe_domain + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_universe_domain( + None, universe_domain_env + ) + == universe_domain_env + ) + assert ( + OrganizationVpcFlowLogsServiceClient._get_universe_domain(None, None) + == OrganizationVpcFlowLogsServiceClient._DEFAULT_UNIVERSE + ) + + with pytest.raises(ValueError) as excinfo: + OrganizationVpcFlowLogsServiceClient._get_universe_domain("", None) + assert str(excinfo.value) == "Universe Domain cannot be an empty string." + + +@pytest.mark.parametrize( + "error_code,cred_info_json,show_cred_info", + [ + (401, CRED_INFO_JSON, True), + (403, CRED_INFO_JSON, True), + (404, CRED_INFO_JSON, True), + (500, CRED_INFO_JSON, False), + (401, None, False), + (403, None, False), + (404, None, False), + (500, None, False), + ], +) +def test__add_cred_info_for_auth_errors(error_code, cred_info_json, show_cred_info): + cred = mock.Mock(["get_cred_info"]) + cred.get_cred_info = mock.Mock(return_value=cred_info_json) + client = OrganizationVpcFlowLogsServiceClient(credentials=cred) + client._transport._credentials = cred + + error = core_exceptions.GoogleAPICallError("message", details=["foo"]) + error.code = error_code + + client._add_cred_info_for_auth_errors(error) + if show_cred_info: + assert error.details == ["foo", CRED_INFO_STRING] + else: + assert error.details == ["foo"] + + +@pytest.mark.parametrize("error_code", [401, 403, 404, 500]) +def test__add_cred_info_for_auth_errors_no_get_cred_info(error_code): + cred = mock.Mock([]) + assert not hasattr(cred, "get_cred_info") + client = OrganizationVpcFlowLogsServiceClient(credentials=cred) + client._transport._credentials = cred + + error = core_exceptions.GoogleAPICallError("message", details=[]) + error.code = error_code + + client._add_cred_info_for_auth_errors(error) + assert error.details == [] + + +@pytest.mark.parametrize( + "client_class,transport_name", + [ + (OrganizationVpcFlowLogsServiceClient, "grpc"), + (OrganizationVpcFlowLogsServiceAsyncClient, "grpc_asyncio"), + (OrganizationVpcFlowLogsServiceClient, "rest"), + ], +) +def test_organization_vpc_flow_logs_service_client_from_service_account_info( + client_class, transport_name +): + creds = ga_credentials.AnonymousCredentials() + with mock.patch.object( + service_account.Credentials, "from_service_account_info" + ) as factory: + factory.return_value = creds + info = {"valid": True} + client = client_class.from_service_account_info(info, transport=transport_name) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + assert client.transport._host == ( + "networkmanagement.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://networkmanagement.googleapis.com" + ) + + +@pytest.mark.parametrize( + "transport_class,transport_name", + [ + (transports.OrganizationVpcFlowLogsServiceGrpcTransport, "grpc"), + (transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, "grpc_asyncio"), + (transports.OrganizationVpcFlowLogsServiceRestTransport, "rest"), + ], +) +def test_organization_vpc_flow_logs_service_client_service_account_always_use_jwt( + transport_class, transport_name +): + with mock.patch.object( + service_account.Credentials, "with_always_use_jwt_access", create=True + ) as use_jwt: + creds = service_account.Credentials(None, None, None) + transport = transport_class(credentials=creds, always_use_jwt_access=True) + use_jwt.assert_called_once_with(True) + + with mock.patch.object( + service_account.Credentials, "with_always_use_jwt_access", create=True + ) as use_jwt: + creds = service_account.Credentials(None, None, None) + transport = transport_class(credentials=creds, always_use_jwt_access=False) + use_jwt.assert_not_called() + + +@pytest.mark.parametrize( + "client_class,transport_name", + [ + (OrganizationVpcFlowLogsServiceClient, "grpc"), + (OrganizationVpcFlowLogsServiceAsyncClient, "grpc_asyncio"), + (OrganizationVpcFlowLogsServiceClient, "rest"), + ], +) +def test_organization_vpc_flow_logs_service_client_from_service_account_file( + client_class, transport_name +): + creds = ga_credentials.AnonymousCredentials() + with mock.patch.object( + service_account.Credentials, "from_service_account_file" + ) as factory: + factory.return_value = creds + client = client_class.from_service_account_file( + "dummy/file/path.json", transport=transport_name + ) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + client = client_class.from_service_account_json( + "dummy/file/path.json", transport=transport_name + ) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + assert client.transport._host == ( + "networkmanagement.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://networkmanagement.googleapis.com" + ) + + +def test_organization_vpc_flow_logs_service_client_get_transport_class(): + transport = OrganizationVpcFlowLogsServiceClient.get_transport_class() + available_transports = [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceRestTransport, + ] + assert transport in available_transports + + transport = OrganizationVpcFlowLogsServiceClient.get_transport_class("grpc") + assert transport == transports.OrganizationVpcFlowLogsServiceGrpcTransport + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + "grpc", + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + "grpc_asyncio", + ), + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceRestTransport, + "rest", + ), + ], +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceClient), +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceAsyncClient), +) +def test_organization_vpc_flow_logs_service_client_client_options( + client_class, transport_class, transport_name +): + # Check that if channel is provided we won't create a new one. + with mock.patch.object( + OrganizationVpcFlowLogsServiceClient, "get_transport_class" + ) as gtc: + transport = transport_class(credentials=ga_credentials.AnonymousCredentials()) + client = client_class(transport=transport) + gtc.assert_not_called() + + # Check that if channel is provided via str we will create a new one. + with mock.patch.object( + OrganizationVpcFlowLogsServiceClient, "get_transport_class" + ) as gtc: + client = client_class(transport=transport_name) + gtc.assert_called() + + # Check the case api_endpoint is provided. + options = client_options.ClientOptions(api_endpoint="squid.clam.whelk") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(transport=transport_name, client_options=options) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host="squid.clam.whelk", + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is + # "never". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is + # "always". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_MTLS_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has + # unsupported value. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError) as excinfo: + client = client_class(transport=transport_name) + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + # Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError) as excinfo: + client = client_class(transport=transport_name) + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + + # Check the case quota_project_id is provided + options = client_options.ClientOptions(quota_project_id="octopus") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id="octopus", + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + # Check the case api_endpoint is provided + options = client_options.ClientOptions( + api_audience="https://language.googleapis.com" + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience="https://language.googleapis.com", + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,use_client_cert_env", + [ + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + "grpc", + "true", + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + "grpc_asyncio", + "true", + ), + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + "grpc", + "false", + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + "grpc_asyncio", + "false", + ), + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceRestTransport, + "rest", + "true", + ), + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceRestTransport, + "rest", + "false", + ), + ], +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceClient), +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceAsyncClient), +) +@mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"}) +def test_organization_vpc_flow_logs_service_client_mtls_env_auto( + client_class, transport_class, transport_name, use_client_cert_env +): + # This tests the endpoint autoswitch behavior. Endpoint is autoswitched to the default + # mtls endpoint, if GOOGLE_API_USE_CLIENT_CERTIFICATE is "true" and client cert exists. + + # Check the case client_cert_source is provided. Whether client cert is used depends on + # GOOGLE_API_USE_CLIENT_CERTIFICATE value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + options = client_options.ClientOptions( + client_cert_source=client_cert_source_callback + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + + if use_client_cert_env == "false": + expected_client_cert_source = None + expected_host = client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ) + else: + expected_client_cert_source = client_cert_source_callback + expected_host = client.DEFAULT_MTLS_ENDPOINT + + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=expected_host, + scopes=None, + client_cert_source_for_mtls=expected_client_cert_source, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case ADC client cert is provided. Whether client cert is used depends on + # GOOGLE_API_USE_CLIENT_CERTIFICATE value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + with mock.patch.object(transport_class, "__init__") as patched: + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=True, + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=client_cert_source_callback, + ): + if use_client_cert_env == "false": + expected_host = client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ) + expected_client_cert_source = None + else: + expected_host = client.DEFAULT_MTLS_ENDPOINT + expected_client_cert_source = client_cert_source_callback + + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=expected_host, + scopes=None, + client_cert_source_for_mtls=expected_client_cert_source, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # Check the case client_cert_source and ADC client cert are not provided. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + with mock.patch.object(transport_class, "__init__") as patched: + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=False, + ): + patched.return_value = None + client = client_class(transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +@pytest.mark.parametrize( + "client_class", + [OrganizationVpcFlowLogsServiceClient, OrganizationVpcFlowLogsServiceAsyncClient], +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceClient, + "DEFAULT_ENDPOINT", + modify_default_endpoint(OrganizationVpcFlowLogsServiceClient), +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceAsyncClient, + "DEFAULT_ENDPOINT", + modify_default_endpoint(OrganizationVpcFlowLogsServiceAsyncClient), +) +def test_organization_vpc_flow_logs_service_client_get_mtls_endpoint_and_cert_source( + client_class, +): + mock_client_cert_source = mock.Mock() + + # Test the case GOOGLE_API_USE_CLIENT_CERTIFICATE is "true". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + mock_api_endpoint = "foo" + options = client_options.ClientOptions( + client_cert_source=mock_client_cert_source, api_endpoint=mock_api_endpoint + ) + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source( + options + ) + assert api_endpoint == mock_api_endpoint + assert cert_source == mock_client_cert_source + + # Test the case GOOGLE_API_USE_CLIENT_CERTIFICATE is "false". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}): + mock_client_cert_source = mock.Mock() + mock_api_endpoint = "foo" + options = client_options.ClientOptions( + client_cert_source=mock_client_cert_source, api_endpoint=mock_api_endpoint + ) + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source( + options + ) + assert api_endpoint == mock_api_endpoint + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "never". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_ENDPOINT + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "always". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "auto" and default cert doesn't exist. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=False, + ): + api_endpoint, cert_source = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_ENDPOINT + assert cert_source is None + + # Test the case GOOGLE_API_USE_MTLS_ENDPOINT is "auto" and default cert exists. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=True, + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=mock_client_cert_source, + ): + ( + api_endpoint, + cert_source, + ) = client_class.get_mtls_endpoint_and_cert_source() + assert api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT + assert cert_source == mock_client_cert_source + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has + # unsupported value. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError) as excinfo: + client_class.get_mtls_endpoint_and_cert_source() + + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`" + ) + + # Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError) as excinfo: + client_class.get_mtls_endpoint_and_cert_source() + + assert ( + str(excinfo.value) + == "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" + ) + + +@pytest.mark.parametrize( + "client_class", + [OrganizationVpcFlowLogsServiceClient, OrganizationVpcFlowLogsServiceAsyncClient], +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceClient), +) +@mock.patch.object( + OrganizationVpcFlowLogsServiceAsyncClient, + "_DEFAULT_ENDPOINT_TEMPLATE", + modify_default_endpoint_template(OrganizationVpcFlowLogsServiceAsyncClient), +) +def test_organization_vpc_flow_logs_service_client_client_api_endpoint(client_class): + mock_client_cert_source = client_cert_source_callback + api_override = "foo.com" + default_universe = OrganizationVpcFlowLogsServiceClient._DEFAULT_UNIVERSE + default_endpoint = ( + OrganizationVpcFlowLogsServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=default_universe + ) + ) + mock_universe = "bar.com" + mock_endpoint = ( + OrganizationVpcFlowLogsServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=mock_universe + ) + ) + + # If ClientOptions.api_endpoint is set and GOOGLE_API_USE_CLIENT_CERTIFICATE="true", + # use ClientOptions.api_endpoint as the api endpoint regardless. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}): + with mock.patch( + "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel" + ): + options = client_options.ClientOptions( + client_cert_source=mock_client_cert_source, api_endpoint=api_override + ) + client = client_class( + client_options=options, + credentials=ga_credentials.AnonymousCredentials(), + ) + assert client.api_endpoint == api_override + + # If ClientOptions.api_endpoint is not set and GOOGLE_API_USE_MTLS_ENDPOINT="never", + # use the _DEFAULT_ENDPOINT_TEMPLATE populated with GDU as the api endpoint. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + client = client_class(credentials=ga_credentials.AnonymousCredentials()) + assert client.api_endpoint == default_endpoint + + # If ClientOptions.api_endpoint is not set and GOOGLE_API_USE_MTLS_ENDPOINT="always", + # use the DEFAULT_MTLS_ENDPOINT as the api endpoint. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + client = client_class(credentials=ga_credentials.AnonymousCredentials()) + assert client.api_endpoint == client_class.DEFAULT_MTLS_ENDPOINT + + # If ClientOptions.api_endpoint is not set, GOOGLE_API_USE_MTLS_ENDPOINT="auto" (default), + # GOOGLE_API_USE_CLIENT_CERTIFICATE="false" (default), default cert source doesn't exist, + # and ClientOptions.universe_domain="bar.com", + # use the _DEFAULT_ENDPOINT_TEMPLATE populated with universe domain as the api endpoint. + options = client_options.ClientOptions() + universe_exists = hasattr(options, "universe_domain") + if universe_exists: + options = client_options.ClientOptions(universe_domain=mock_universe) + client = client_class( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + else: + client = client_class( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + assert client.api_endpoint == ( + mock_endpoint if universe_exists else default_endpoint + ) + assert client.universe_domain == ( + mock_universe if universe_exists else default_universe + ) + + # If ClientOptions does not have a universe domain attribute and GOOGLE_API_USE_MTLS_ENDPOINT="never", + # use the _DEFAULT_ENDPOINT_TEMPLATE populated with GDU as the api endpoint. + options = client_options.ClientOptions() + if hasattr(options, "universe_domain"): + delattr(options, "universe_domain") + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + client = client_class( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + assert client.api_endpoint == default_endpoint + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + "grpc", + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + "grpc_asyncio", + ), + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceRestTransport, + "rest", + ), + ], +) +def test_organization_vpc_flow_logs_service_client_client_options_scopes( + client_class, transport_class, transport_name +): + # Check the case scopes are provided. + options = client_options.ClientOptions( + scopes=["1", "2"], + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=["1", "2"], + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,grpc_helpers", + [ + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + "grpc", + grpc_helpers, + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + "grpc_asyncio", + grpc_helpers_async, + ), + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceRestTransport, + "rest", + None, + ), + ], +) +def test_organization_vpc_flow_logs_service_client_client_options_credentials_file( + client_class, transport_class, transport_name, grpc_helpers +): + # Check the case credentials file is provided. + options = client_options.ClientOptions(credentials_file="credentials.json") + + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file="credentials.json", + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +def test_organization_vpc_flow_logs_service_client_client_options_from_dict(): + with mock.patch( + "google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.transports.OrganizationVpcFlowLogsServiceGrpcTransport.__init__" + ) as grpc_transport: + grpc_transport.return_value = None + client = OrganizationVpcFlowLogsServiceClient( + client_options={"api_endpoint": "squid.clam.whelk"} + ) + grpc_transport.assert_called_once_with( + credentials=None, + credentials_file=None, + host="squid.clam.whelk", + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,grpc_helpers", + [ + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + "grpc", + grpc_helpers, + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + "grpc_asyncio", + grpc_helpers_async, + ), + ], +) +def test_organization_vpc_flow_logs_service_client_create_channel_credentials_file( + client_class, transport_class, transport_name, grpc_helpers +): + # Check the case credentials file is provided. + options = client_options.ClientOptions(credentials_file="credentials.json") + + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options, transport=transport_name) + patched.assert_called_once_with( + credentials=None, + credentials_file="credentials.json", + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) + + # test that the credentials from file are saved and used as the credentials. + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch.object( + google.auth, "default", autospec=True + ) as adc, mock.patch.object( + grpc_helpers, "create_channel" + ) as create_channel: + creds = ga_credentials.AnonymousCredentials() + file_creds = ga_credentials.AnonymousCredentials() + load_creds.return_value = (file_creds, None) + adc.return_value = (creds, None) + client = client_class(client_options=options, transport=transport_name) + create_channel.assert_called_with( + "networkmanagement.googleapis.com:443", + credentials=file_creds, + credentials_file=None, + quota_project_id=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + scopes=None, + default_host="networkmanagement.googleapis.com", + ssl_credentials=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + dict, + ], +) +def test_list_vpc_flow_logs_configs(request_type, transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + response = client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListVpcFlowLogsConfigsPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +def test_list_vpc_flow_logs_configs_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + order_by="order_by_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_vpc_flow_logs_configs(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.ListVpcFlowLogsConfigsRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + order_by="order_by_value", + ) + + +def test_list_vpc_flow_logs_configs_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_vpc_flow_logs_configs + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_vpc_flow_logs_configs + ] = mock_rpc + request = {} + client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_vpc_flow_logs_configs(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.list_vpc_flow_logs_configs + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.list_vpc_flow_logs_configs + ] = mock_rpc + + request = {} + await client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.list_vpc_flow_logs_configs(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.ListVpcFlowLogsConfigsRequest, +): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + ) + response = await client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListVpcFlowLogsConfigsAsyncPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_async_from_dict(): + await test_list_vpc_flow_logs_configs_async(request_type=dict) + + +def test_list_vpc_flow_logs_configs_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + ) + await client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_list_vpc_flow_logs_configs_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_vpc_flow_logs_configs( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +def test_list_vpc_flow_logs_configs_flattened_error(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_vpc_flow_logs_configs( + vpc_flow_logs.ListVpcFlowLogsConfigsRequest(), + parent="parent_value", + ) + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_flattened_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_vpc_flow_logs_configs( + parent="parent_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_flattened_error_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.list_vpc_flow_logs_configs( + vpc_flow_logs.ListVpcFlowLogsConfigsRequest(), + parent="parent_value", + ) + + +def test_list_vpc_flow_logs_configs_pager(transport_name: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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_vpc_flow_logs_configs), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_vpc_flow_logs_configs( + request={}, retry=retry, timeout=timeout + ) + + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.VpcFlowLogsConfig) for i in results + ) + + +def test_list_vpc_flow_logs_configs_pages(transport_name: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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_vpc_flow_logs_configs), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + pages = list(client.list_vpc_flow_logs_configs(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_vpc_flow_logs_configs_async_pager(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + async_pager = await client.list_vpc_flow_logs_configs( + 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, vpc_flow_logs_config.VpcFlowLogsConfig) for i in responses + ) + + +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_async_pages(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + 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_vpc_flow_logs_configs(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", + [ + vpc_flow_logs.GetVpcFlowLogsConfigRequest, + dict, + ], +) +def test_get_vpc_flow_logs_config(request_type, transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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.get_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value", + description="description_value", + state=vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED, + aggregation_interval=vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC, + flow_sampling=0.1394, + metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, + metadata_fields=["metadata_fields_value"], + filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, + target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, + network="network_value", + ) + response = client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, vpc_flow_logs_config.VpcFlowLogsConfig) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.state == vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED + assert ( + response.aggregation_interval + == vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC + ) + assert math.isclose(response.flow_sampling, 0.1394, rel_tol=1e-6) + assert ( + response.metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA + ) + assert response.metadata_fields == ["metadata_fields_value"] + assert response.filter_expr == "filter_expr_value" + assert ( + response.cross_project_metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED + ) + assert ( + response.target_resource_state + == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS + ) + + +def test_get_vpc_flow_logs_config_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_vpc_flow_logs_config(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.GetVpcFlowLogsConfigRequest( + name="name_value", + ) + + +def test_get_vpc_flow_logs_config_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.get_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.get_vpc_flow_logs_config + ] = mock_rpc + request = {} + client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.get_vpc_flow_logs_config + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.get_vpc_flow_logs_config + ] = mock_rpc + + request = {} + await client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.get_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.GetVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.get_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value", + description="description_value", + state=vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED, + aggregation_interval=vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC, + flow_sampling=0.1394, + metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, + metadata_fields=["metadata_fields_value"], + filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, + target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, + ) + ) + response = await client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, vpc_flow_logs_config.VpcFlowLogsConfig) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.state == vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED + assert ( + response.aggregation_interval + == vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC + ) + assert math.isclose(response.flow_sampling, 0.1394, rel_tol=1e-6) + assert ( + response.metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA + ) + assert response.metadata_fields == ["metadata_fields_value"] + assert response.filter_expr == "filter_expr_value" + assert ( + response.cross_project_metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED + ) + assert ( + response.target_resource_state + == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS + ) + + +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_async_from_dict(): + await test_get_vpc_flow_logs_config_async(request_type=dict) + + +def test_get_vpc_flow_logs_config_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs_config.VpcFlowLogsConfig() + ) + await client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_get_vpc_flow_logs_config_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_vpc_flow_logs_config( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_get_vpc_flow_logs_config_flattened_error(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_vpc_flow_logs_config( + vpc_flow_logs.GetVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_flattened_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs_config.VpcFlowLogsConfig() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_vpc_flow_logs_config( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_flattened_error_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_vpc_flow_logs_config( + vpc_flow_logs.GetVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + dict, + ], +) +def test_create_vpc_flow_logs_config(request_type, transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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.create_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_create_vpc_flow_logs_config_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest( + parent="parent_value", + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.create_vpc_flow_logs_config(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.CreateVpcFlowLogsConfigRequest( + parent="parent_value", + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + +def test_create_vpc_flow_logs_config_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.create_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.create_vpc_flow_logs_config + ] = mock_rpc + request = {} + client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.create_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.create_vpc_flow_logs_config + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.create_vpc_flow_logs_config + ] = mock_rpc + + request = {} + await client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + await client.create_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.create_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_async_from_dict(): + await test_create_vpc_flow_logs_config_async(request_type=dict) + + +def test_create_vpc_flow_logs_config_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_create_vpc_flow_logs_config_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.create_vpc_flow_logs_config( + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].vpc_flow_logs_config + mock_val = gcn_vpc_flow_logs_config.VpcFlowLogsConfig(name="name_value") + assert arg == mock_val + arg = args[0].vpc_flow_logs_config_id + mock_val = "vpc_flow_logs_config_id_value" + assert arg == mock_val + + +def test_create_vpc_flow_logs_config_flattened_error(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_vpc_flow_logs_config( + vpc_flow_logs.CreateVpcFlowLogsConfigRequest(), + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_flattened_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.create_vpc_flow_logs_config( + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].vpc_flow_logs_config + mock_val = gcn_vpc_flow_logs_config.VpcFlowLogsConfig(name="name_value") + assert arg == mock_val + arg = args[0].vpc_flow_logs_config_id + mock_val = "vpc_flow_logs_config_id_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_flattened_error_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.create_vpc_flow_logs_config( + vpc_flow_logs.CreateVpcFlowLogsConfigRequest(), + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, + dict, + ], +) +def test_update_vpc_flow_logs_config(request_type, transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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.update_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_update_vpc_flow_logs_config_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.update_vpc_flow_logs_config(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + +def test_update_vpc_flow_logs_config_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.update_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.update_vpc_flow_logs_config + ] = mock_rpc + request = {} + client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.update_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.update_vpc_flow_logs_config + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.update_vpc_flow_logs_config + ] = mock_rpc + + request = {} + await client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + await client.update_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.update_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_async_from_dict(): + await test_update_vpc_flow_logs_config_async(request_type=dict) + + +def test_update_vpc_flow_logs_config_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + request.vpc_flow_logs_config.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "vpc_flow_logs_config.name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + request.vpc_flow_logs_config.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "vpc_flow_logs_config.name=name_value", + ) in kw["metadata"] + + +def test_update_vpc_flow_logs_config_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.update_vpc_flow_logs_config( + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].vpc_flow_logs_config + mock_val = gcn_vpc_flow_logs_config.VpcFlowLogsConfig(name="name_value") + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val + + +def test_update_vpc_flow_logs_config_flattened_error(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_vpc_flow_logs_config( + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(), + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_flattened_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.update_vpc_flow_logs_config( + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].vpc_flow_logs_config + mock_val = gcn_vpc_flow_logs_config.VpcFlowLogsConfig(name="name_value") + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_flattened_error_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.update_vpc_flow_logs_config( + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(), + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + dict, + ], +) +def test_delete_vpc_flow_logs_config(request_type, transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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.delete_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_delete_vpc_flow_logs_config_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_vpc_flow_logs_config(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.DeleteVpcFlowLogsConfigRequest( + name="name_value", + ) + + +def test_delete_vpc_flow_logs_config_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.delete_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.delete_vpc_flow_logs_config + ] = mock_rpc + request = {} + client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.delete_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.delete_vpc_flow_logs_config + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.delete_vpc_flow_logs_config + ] = mock_rpc + + request = {} + await client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + await client.delete_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.delete_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_async_from_dict(): + await test_delete_vpc_flow_logs_config_async(request_type=dict) + + +def test_delete_vpc_flow_logs_config_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_delete_vpc_flow_logs_config_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.delete_vpc_flow_logs_config( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_delete_vpc_flow_logs_config_flattened_error(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_vpc_flow_logs_config( + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_flattened_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.delete_vpc_flow_logs_config( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_flattened_error_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.delete_vpc_flow_logs_config( + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +def test_list_vpc_flow_logs_configs_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_vpc_flow_logs_configs + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_vpc_flow_logs_configs + ] = mock_rpc + + request = {} + client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_vpc_flow_logs_configs(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_vpc_flow_logs_configs_rest_required_fields( + request_type=vpc_flow_logs.ListVpcFlowLogsConfigsRequest, +): + transport_class = transports.OrganizationVpcFlowLogsServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_vpc_flow_logs_configs._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_vpc_flow_logs_configs._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_vpc_flow_logs_configs(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_vpc_flow_logs_configs_rest_unset_required_fields(): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_vpc_flow_logs_configs._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_vpc_flow_logs_configs_rest_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + 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 = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "organizations/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.list_vpc_flow_logs_configs(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=organizations/*/locations/*}/vpcFlowLogsConfigs" + % client.transport._host, + args[1], + ) + + +def test_list_vpc_flow_logs_configs_rest_flattened_error(transport: str = "rest"): + client = OrganizationVpcFlowLogsServiceClient( + 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_vpc_flow_logs_configs( + vpc_flow_logs.ListVpcFlowLogsConfigsRequest(), + parent="parent_value", + ) + + +def test_list_vpc_flow_logs_configs_rest_pager(transport: str = "rest"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse.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": "organizations/sample1/locations/sample2"} + + pager = client.list_vpc_flow_logs_configs(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.VpcFlowLogsConfig) for i in results + ) + + pages = list(client.list_vpc_flow_logs_configs(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.get_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.get_vpc_flow_logs_config + ] = mock_rpc + + request = {} + client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_get_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.GetVpcFlowLogsConfigRequest, +): + transport_class = transports.OrganizationVpcFlowLogsServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_vpc_flow_logs_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_vpc_flow_logs_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 = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_vpc_flow_logs_config(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_vpc_flow_logs_config_rest_unset_required_fields(): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_vpc_flow_logs_config_rest_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + 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 = vpc_flow_logs_config.VpcFlowLogsConfig() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.get_vpc_flow_logs_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/v1/{name=organizations/*/locations/*/vpcFlowLogsConfigs/*}" + % client.transport._host, + args[1], + ) + + +def test_get_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): + client = OrganizationVpcFlowLogsServiceClient( + 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_vpc_flow_logs_config( + vpc_flow_logs.GetVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +def test_create_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.create_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.create_vpc_flow_logs_config + ] = mock_rpc + + request = {} + client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.create_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_create_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +): + transport_class = transports.OrganizationVpcFlowLogsServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request_init["vpc_flow_logs_config_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + assert "vpcFlowLogsConfigId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "vpcFlowLogsConfigId" in jsonified_request + assert ( + jsonified_request["vpcFlowLogsConfigId"] + == request_init["vpc_flow_logs_config_id"] + ) + + jsonified_request["parent"] = "parent_value" + jsonified_request["vpcFlowLogsConfigId"] = "vpc_flow_logs_config_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("vpc_flow_logs_config_id",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "vpcFlowLogsConfigId" in jsonified_request + assert jsonified_request["vpcFlowLogsConfigId"] == "vpc_flow_logs_config_id_value" + + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.create_vpc_flow_logs_config(request) + + expected_params = [ + ( + "vpcFlowLogsConfigId", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_vpc_flow_logs_config_rest_unset_required_fields(): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("vpcFlowLogsConfigId",)) + & set( + ( + "parent", + "vpcFlowLogsConfigId", + "vpcFlowLogsConfig", + ) + ) + ) + + +def test_create_vpc_flow_logs_config_rest_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "organizations/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.create_vpc_flow_logs_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/v1/{parent=organizations/*/locations/*}/vpcFlowLogsConfigs" + % client.transport._host, + args[1], + ) + + +def test_create_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_vpc_flow_logs_config( + vpc_flow_logs.CreateVpcFlowLogsConfigRequest(), + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + + +def test_update_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.update_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.update_vpc_flow_logs_config + ] = mock_rpc + + request = {} + client.update_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.update_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_update_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, +): + transport_class = transports.OrganizationVpcFlowLogsServiceRestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_vpc_flow_logs_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_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # 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 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.update_vpc_flow_logs_config(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_vpc_flow_logs_config_rest_unset_required_fields(): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "updateMask", + "vpcFlowLogsConfig", + ) + ) + ) + + +def test_update_vpc_flow_logs_config_rest_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "vpc_flow_logs_config": { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + } + + # get truthy value for each flattened field + mock_args = dict( + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.update_vpc_flow_logs_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/v1/{vpc_flow_logs_config.name=organizations/*/locations/*/vpcFlowLogsConfigs/*}" + % client.transport._host, + args[1], + ) + + +def test_update_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): + client = OrganizationVpcFlowLogsServiceClient( + 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_vpc_flow_logs_config( + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(), + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_delete_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.delete_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.delete_vpc_flow_logs_config + ] = mock_rpc + + request = {} + client.delete_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.delete_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_delete_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, +): + transport_class = transports.OrganizationVpcFlowLogsServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_vpc_flow_logs_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() + ).delete_vpc_flow_logs_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 = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.delete_vpc_flow_logs_config(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_vpc_flow_logs_config_rest_unset_required_fields(): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_vpc_flow_logs_config_rest_flattened(): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.delete_vpc_flow_logs_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/v1/{name=organizations/*/locations/*/vpcFlowLogsConfigs/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_vpc_flow_logs_config( + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = OrganizationVpcFlowLogsServiceClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide an api_key and a transport instance. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = OrganizationVpcFlowLogsServiceClient( + client_options=options, + transport=transport, + ) + + # It is an error to provide an api_key and a credential. + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = OrganizationVpcFlowLogsServiceClient( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = OrganizationVpcFlowLogsServiceClient( + client_options={"scopes": ["1", "2"]}, + transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = OrganizationVpcFlowLogsServiceClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + transports.OrganizationVpcFlowLogsServiceRestTransport, + ], +) +def test_transport_adc(transport_class): + # Test default credentials are used if not provided. + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class() + adc.assert_called_once() + + +def test_transport_kind_grpc(): + transport = OrganizationVpcFlowLogsServiceClient.get_transport_class("grpc")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "grpc" + + +def test_initialize_client_w_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc" + ) + assert client is not None + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_vpc_flow_logs_configs_empty_call_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + client.list_vpc_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_get_vpc_flow_logs_config_empty_call_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + client.get_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_create_vpc_flow_logs_config_empty_call_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.create_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_update_vpc_flow_logs_config_empty_call_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.update_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_delete_vpc_flow_logs_config_empty_call_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.delete_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +def test_transport_kind_grpc_asyncio(): + transport = OrganizationVpcFlowLogsServiceAsyncClient.get_transport_class( + "grpc_asyncio" + )(credentials=async_anonymous_credentials()) + assert transport.kind == "grpc_asyncio" + + +def test_initialize_client_w_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), transport="grpc_asyncio" + ) + assert client is not None + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_list_vpc_flow_logs_configs_empty_call_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + ) + await client.list_vpc_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_get_vpc_flow_logs_config_empty_call_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value", + description="description_value", + state=vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED, + aggregation_interval=vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC, + flow_sampling=0.1394, + metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, + metadata_fields=["metadata_fields_value"], + filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, + target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, + ) + ) + await client.get_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_empty_call_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.create_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_empty_call_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.update_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_delete_vpc_flow_logs_config_empty_call_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.delete_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +def test_transport_kind_rest(): + transport = OrganizationVpcFlowLogsServiceClient.get_transport_class("rest")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "rest" + + +def test_list_vpc_flow_logs_configs_rest_bad_request( + request_type=vpc_flow_logs.ListVpcFlowLogsConfigsRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_vpc_flow_logs_configs(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.ListVpcFlowLogsConfigsRequest, + dict, + ], +) +def test_list_vpc_flow_logs_configs_rest_call_success(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.list_vpc_flow_logs_configs(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListVpcFlowLogsConfigsPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_vpc_flow_logs_configs_rest_interceptors(null_interceptor): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.OrganizationVpcFlowLogsServiceRestInterceptor(), + ) + client = OrganizationVpcFlowLogsServiceClient(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.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_list_vpc_flow_logs_configs", + ) as post, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_list_vpc_flow_logs_configs_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "pre_list_vpc_flow_logs_configs", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.ListVpcFlowLogsConfigsRequest.pb( + vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.to_json( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + ) + req.return_value.content = return_value + + request = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + post_with_metadata.return_value = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse(), + metadata, + ) + + client.list_vpc_flow_logs_configs( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.GetVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_vpc_flow_logs_config(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.GetVpcFlowLogsConfigRequest, + dict, + ], +) +def test_get_vpc_flow_logs_config_rest_call_success(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/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 = vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value", + description="description_value", + state=vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED, + aggregation_interval=vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC, + flow_sampling=0.1394, + metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, + metadata_fields=["metadata_fields_value"], + filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, + target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, + network="network_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.get_vpc_flow_logs_config(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, vpc_flow_logs_config.VpcFlowLogsConfig) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.state == vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED + assert ( + response.aggregation_interval + == vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC + ) + assert math.isclose(response.flow_sampling, 0.1394, rel_tol=1e-6) + assert ( + response.metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA + ) + assert response.metadata_fields == ["metadata_fields_value"] + assert response.filter_expr == "filter_expr_value" + assert ( + response.cross_project_metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED + ) + assert ( + response.target_resource_state + == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_vpc_flow_logs_config_rest_interceptors(null_interceptor): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.OrganizationVpcFlowLogsServiceRestInterceptor(), + ) + client = OrganizationVpcFlowLogsServiceClient(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.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_get_vpc_flow_logs_config", + ) as post, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_get_vpc_flow_logs_config_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "pre_get_vpc_flow_logs_config", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.GetVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.GetVpcFlowLogsConfigRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.to_json( + vpc_flow_logs_config.VpcFlowLogsConfig() + ) + req.return_value.content = return_value + + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + post_with_metadata.return_value = ( + vpc_flow_logs_config.VpcFlowLogsConfig(), + metadata, + ) + + client.get_vpc_flow_logs_config( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_create_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.create_vpc_flow_logs_config(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + dict, + ], +) +def test_create_vpc_flow_logs_config_rest_call_success(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "organizations/sample1/locations/sample2"} + request_init["vpc_flow_logs_config"] = { + "name": "name_value", + "description": "description_value", + "state": 1, + "aggregation_interval": 1, + "flow_sampling": 0.1394, + "metadata": 1, + "metadata_fields": ["metadata_fields_value1", "metadata_fields_value2"], + "filter_expr": "filter_expr_value", + "cross_project_metadata": 1, + "target_resource_state": 1, + "network": "network_value", + "subnet": "subnet_value", + "interconnect_attachment": "interconnect_attachment_value", + "vpn_tunnel": "vpn_tunnel_value", + "labels": {}, + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.meta.fields[ + "vpc_flow_logs_config" + ] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init[ + "vpc_flow_logs_config" + ].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["vpc_flow_logs_config"][field])): + del request_init["vpc_flow_logs_config"][field][i][subfield] + else: + del request_init["vpc_flow_logs_config"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.create_vpc_flow_logs_config(request) + + # Establish that the response is the type that we expect. + json_return_value = json_format.MessageToJson(return_value) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.OrganizationVpcFlowLogsServiceRestInterceptor(), + ) + client = OrganizationVpcFlowLogsServiceClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_create_vpc_flow_logs_config", + ) as post, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_create_vpc_flow_logs_config_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "pre_create_vpc_flow_logs_config", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value + + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata + + client.create_vpc_flow_logs_config( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_update_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "vpc_flow_logs_config": { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.update_vpc_flow_logs_config(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, + dict, + ], +) +def test_update_vpc_flow_logs_config_rest_call_success(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "vpc_flow_logs_config": { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + } + request_init["vpc_flow_logs_config"] = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/sample3", + "description": "description_value", + "state": 1, + "aggregation_interval": 1, + "flow_sampling": 0.1394, + "metadata": 1, + "metadata_fields": ["metadata_fields_value1", "metadata_fields_value2"], + "filter_expr": "filter_expr_value", + "cross_project_metadata": 1, + "target_resource_state": 1, + "network": "network_value", + "subnet": "subnet_value", + "interconnect_attachment": "interconnect_attachment_value", + "vpn_tunnel": "vpn_tunnel_value", + "labels": {}, + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.meta.fields[ + "vpc_flow_logs_config" + ] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init[ + "vpc_flow_logs_config" + ].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["vpc_flow_logs_config"][field])): + del request_init["vpc_flow_logs_config"][field][i][subfield] + else: + del request_init["vpc_flow_logs_config"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.update_vpc_flow_logs_config(request) + + # Establish that the response is the type that we expect. + json_return_value = json_format.MessageToJson(return_value) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_vpc_flow_logs_config_rest_interceptors(null_interceptor): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.OrganizationVpcFlowLogsServiceRestInterceptor(), + ) + client = OrganizationVpcFlowLogsServiceClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_update_vpc_flow_logs_config", + ) as post, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_update_vpc_flow_logs_config_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "pre_update_vpc_flow_logs_config", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value + + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata + + client.update_vpc_flow_logs_config( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_delete_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.delete_vpc_flow_logs_config(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + dict, + ], +) +def test_delete_vpc_flow_logs_config_rest_call_success(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "organizations/sample1/locations/sample2/vpcFlowLogsConfigs/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 = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.delete_vpc_flow_logs_config(request) + + # Establish that the response is the type that we expect. + json_return_value = json_format.MessageToJson(return_value) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_vpc_flow_logs_config_rest_interceptors(null_interceptor): + transport = transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.OrganizationVpcFlowLogsServiceRestInterceptor(), + ) + client = OrganizationVpcFlowLogsServiceClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_delete_vpc_flow_logs_config", + ) as post, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "post_delete_vpc_flow_logs_config_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.OrganizationVpcFlowLogsServiceRestInterceptor, + "pre_delete_vpc_flow_logs_config", + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value + + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata + + client.delete_vpc_flow_logs_config( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_location_rest_bad_request(request_type=locations_pb2.GetLocationRequest): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "projects/sample1/locations/sample2"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_location(request) + + +@pytest.mark.parametrize( + "request_type", + [ + locations_pb2.GetLocationRequest, + dict, + ], +) +def test_get_location_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = locations_pb2.Location() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_location(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.Location) + + +def test_list_locations_rest_bad_request( + request_type=locations_pb2.ListLocationsRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict({"name": "projects/sample1"}, request) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_locations(request) + + +@pytest.mark.parametrize( + "request_type", + [ + locations_pb2.ListLocationsRequest, + dict, + ], +) +def test_list_locations_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "projects/sample1"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = locations_pb2.ListLocationsResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_locations(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.ListLocationsResponse) + + +def test_get_iam_policy_rest_bad_request( + request_type=iam_policy_pb2.GetIamPolicyRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"resource": "projects/sample1/locations/global/connectivityTests/sample2"}, + request, + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_iam_policy(request) + + +@pytest.mark.parametrize( + "request_type", + [ + iam_policy_pb2.GetIamPolicyRequest, + dict, + ], +) +def test_get_iam_policy_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = { + "resource": "projects/sample1/locations/global/connectivityTests/sample2" + } + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = policy_pb2.Policy() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_iam_policy(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + + +def test_set_iam_policy_rest_bad_request( + request_type=iam_policy_pb2.SetIamPolicyRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"resource": "projects/sample1/locations/global/connectivityTests/sample2"}, + request, + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.set_iam_policy(request) + + +@pytest.mark.parametrize( + "request_type", + [ + iam_policy_pb2.SetIamPolicyRequest, + dict, + ], +) +def test_set_iam_policy_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = { + "resource": "projects/sample1/locations/global/connectivityTests/sample2" + } + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = policy_pb2.Policy() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.set_iam_policy(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + + +def test_test_iam_permissions_rest_bad_request( + request_type=iam_policy_pb2.TestIamPermissionsRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"resource": "projects/sample1/locations/global/connectivityTests/sample2"}, + request, + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.test_iam_permissions(request) + + +@pytest.mark.parametrize( + "request_type", + [ + iam_policy_pb2.TestIamPermissionsRequest, + dict, + ], +) +def test_test_iam_permissions_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = { + "resource": "projects/sample1/locations/global/connectivityTests/sample2" + } + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = iam_policy_pb2.TestIamPermissionsResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.test_iam_permissions(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse) + + +def test_cancel_operation_rest_bad_request( + request_type=operations_pb2.CancelOperationRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "projects/sample1/locations/global/operations/sample2"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.cancel_operation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.CancelOperationRequest, + dict, + ], +) +def test_cancel_operation_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "projects/sample1/locations/global/operations/sample2"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = "{}" + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.cancel_operation(request) + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_operation_rest_bad_request( + request_type=operations_pb2.DeleteOperationRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "projects/sample1/locations/global/operations/sample2"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.delete_operation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.DeleteOperationRequest, + dict, + ], +) +def test_delete_operation_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "projects/sample1/locations/global/operations/sample2"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = "{}" + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.delete_operation(request) + + # Establish that the response is the type that we expect. + assert response is None + + +def test_get_operation_rest_bad_request( + request_type=operations_pb2.GetOperationRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "projects/sample1/locations/global/operations/sample2"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_operation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.GetOperationRequest, + dict, + ], +) +def test_get_operation_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "projects/sample1/locations/global/operations/sample2"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_operation(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.Operation) + + +def test_list_operations_rest_bad_request( + request_type=operations_pb2.ListOperationsRequest, +): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type() + request = json_format.ParseDict( + {"name": "projects/sample1/locations/global"}, request + ) + + # 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() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_operations(request) + + +@pytest.mark.parametrize( + "request_type", + [ + operations_pb2.ListOperationsRequest, + dict, + ], +) +def test_list_operations_rest(request_type): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + request_init = {"name": "projects/sample1/locations/global"} + request = request_type(**request_init) + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.ListOperationsResponse() + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_operations(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.ListOperationsResponse) + + +def test_initialize_client_w_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + assert client is not None + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_list_vpc_flow_logs_configs_empty_call_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_vpc_flow_logs_configs), "__call__" + ) as call: + client.list_vpc_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.ListVpcFlowLogsConfigsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_get_vpc_flow_logs_config_empty_call_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_vpc_flow_logs_config), "__call__" + ) as call: + client.get_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_create_vpc_flow_logs_config_empty_call_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + client.create_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_update_vpc_flow_logs_config_empty_call_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + client.update_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_delete_vpc_flow_logs_config_empty_call_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_vpc_flow_logs_config), "__call__" + ) as call: + client.delete_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +def test_organization_vpc_flow_logs_service_rest_lro_client(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + transport = client.transport + + # Ensure that we have an api-core operations client. + assert isinstance( + transport.operations_client, + operations_v1.AbstractOperationsClient, + ) + + # Ensure that subsequent calls to the property send the exact same object. + assert transport.operations_client is transport.operations_client + + +def test_transport_grpc_default(): + # A client should use the gRPC transport by default. + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert isinstance( + client.transport, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + ) + + +def test_organization_vpc_flow_logs_service_base_transport_error(): + # Passing both a credentials object and credentials_file should raise an error + with pytest.raises(core_exceptions.DuplicateCredentialArgs): + transport = transports.OrganizationVpcFlowLogsServiceTransport( + credentials=ga_credentials.AnonymousCredentials(), + credentials_file="credentials.json", + ) + + +def test_organization_vpc_flow_logs_service_base_transport(): + # Instantiate the base transport. + with mock.patch( + "google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.transports.OrganizationVpcFlowLogsServiceTransport.__init__" + ) as Transport: + Transport.return_value = None + transport = transports.OrganizationVpcFlowLogsServiceTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Every method on the transport should just blindly + # raise NotImplementedError. + methods = ( + "list_vpc_flow_logs_configs", + "get_vpc_flow_logs_config", + "create_vpc_flow_logs_config", + "update_vpc_flow_logs_config", + "delete_vpc_flow_logs_config", + "set_iam_policy", + "get_iam_policy", + "test_iam_permissions", + "get_location", + "list_locations", + "get_operation", + "cancel_operation", + "delete_operation", + "list_operations", + ) + for method in methods: + with pytest.raises(NotImplementedError): + getattr(transport, method)(request=object()) + + with pytest.raises(NotImplementedError): + transport.close() + + # Additionally, the LRO client (a property) should + # also raise NotImplementedError + with pytest.raises(NotImplementedError): + transport.operations_client + + # Catch all for all remaining methods and properties + remainder = [ + "kind", + ] + for r in remainder: + with pytest.raises(NotImplementedError): + getattr(transport, r)() + + +def test_organization_vpc_flow_logs_service_base_transport_with_credentials_file(): + # Instantiate the base transport with a credentials file + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch( + "google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.transports.OrganizationVpcFlowLogsServiceTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.OrganizationVpcFlowLogsServiceTransport( + credentials_file="credentials.json", + quota_project_id="octopus", + ) + load_creds.assert_called_once_with( + "credentials.json", + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +def test_organization_vpc_flow_logs_service_base_transport_with_adc(): + # Test the default credentials are used if credentials and credentials_file are None. + with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch( + "google.cloud.network_management_v1.services.organization_vpc_flow_logs_service.transports.OrganizationVpcFlowLogsServiceTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.OrganizationVpcFlowLogsServiceTransport() + adc.assert_called_once() + + +def test_organization_vpc_flow_logs_service_auth_adc(): + # If no credentials are provided, we should use ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + OrganizationVpcFlowLogsServiceClient() + adc.assert_called_once_with( + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id=None, + ) + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + ], +) +def test_organization_vpc_flow_logs_service_transport_auth_adc(transport_class): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class(quota_project_id="octopus", scopes=["1", "2"]) + adc.assert_called_once_with( + scopes=["1", "2"], + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + transports.OrganizationVpcFlowLogsServiceRestTransport, + ], +) +def test_organization_vpc_flow_logs_service_transport_auth_gdch_credentials( + transport_class, +): + host = "https://language.com" + api_audience_tests = [None, "https://language2.com"] + api_audience_expect = [host, "https://language2.com"] + for t, e in zip(api_audience_tests, api_audience_expect): + with mock.patch.object(google.auth, "default", autospec=True) as adc: + gdch_mock = mock.MagicMock() + type(gdch_mock).with_gdch_audience = mock.PropertyMock( + return_value=gdch_mock + ) + adc.return_value = (gdch_mock, None) + transport_class(host=host, api_audience=t) + gdch_mock.with_gdch_audience.assert_called_once_with(e) + + +@pytest.mark.parametrize( + "transport_class,grpc_helpers", + [ + (transports.OrganizationVpcFlowLogsServiceGrpcTransport, grpc_helpers), + ( + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + grpc_helpers_async, + ), + ], +) +def test_organization_vpc_flow_logs_service_transport_create_channel( + transport_class, grpc_helpers +): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object( + google.auth, "default", autospec=True + ) as adc, mock.patch.object( + grpc_helpers, "create_channel", autospec=True + ) as create_channel: + creds = ga_credentials.AnonymousCredentials() + adc.return_value = (creds, None) + transport_class(quota_project_id="octopus", scopes=["1", "2"]) + + create_channel.assert_called_with( + "networkmanagement.googleapis.com:443", + credentials=creds, + credentials_file=None, + quota_project_id="octopus", + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + scopes=["1", "2"], + default_host="networkmanagement.googleapis.com", + ssl_credentials=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + ], +) +def test_organization_vpc_flow_logs_service_grpc_transport_client_cert_source_for_mtls( + transport_class, +): + cred = ga_credentials.AnonymousCredentials() + + # Check ssl_channel_credentials is used if provided. + with mock.patch.object(transport_class, "create_channel") as mock_create_channel: + mock_ssl_channel_creds = mock.Mock() + transport_class( + host="squid.clam.whelk", + credentials=cred, + ssl_channel_credentials=mock_ssl_channel_creds, + ) + mock_create_channel.assert_called_once_with( + "squid.clam.whelk:443", + credentials=cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_channel_creds, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + # Check if ssl_channel_credentials is not provided, then client_cert_source_for_mtls + # is used. + with mock.patch.object(transport_class, "create_channel", return_value=mock.Mock()): + with mock.patch("grpc.ssl_channel_credentials") as mock_ssl_cred: + transport_class( + credentials=cred, + client_cert_source_for_mtls=client_cert_source_callback, + ) + expected_cert, expected_key = client_cert_source_callback() + mock_ssl_cred.assert_called_once_with( + certificate_chain=expected_cert, private_key=expected_key + ) + + +def test_organization_vpc_flow_logs_service_http_transport_client_cert_source_for_mtls(): + cred = ga_credentials.AnonymousCredentials() + with mock.patch( + "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel" + ) as mock_configure_mtls_channel: + transports.OrganizationVpcFlowLogsServiceRestTransport( + credentials=cred, client_cert_source_for_mtls=client_cert_source_callback + ) + mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback) + + +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + "rest", + ], +) +def test_organization_vpc_flow_logs_service_host_no_port(transport_name): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + client_options=client_options.ClientOptions( + api_endpoint="networkmanagement.googleapis.com" + ), + transport=transport_name, + ) + assert client.transport._host == ( + "networkmanagement.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://networkmanagement.googleapis.com" + ) + + +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + "rest", + ], +) +def test_organization_vpc_flow_logs_service_host_with_port(transport_name): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + client_options=client_options.ClientOptions( + api_endpoint="networkmanagement.googleapis.com:8000" + ), + transport=transport_name, + ) + assert client.transport._host == ( + "networkmanagement.googleapis.com:8000" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://networkmanagement.googleapis.com:8000" + ) + + +@pytest.mark.parametrize( + "transport_name", + [ + "rest", + ], +) +def test_organization_vpc_flow_logs_service_client_transport_session_collision( + transport_name, +): + creds1 = ga_credentials.AnonymousCredentials() + creds2 = ga_credentials.AnonymousCredentials() + client1 = OrganizationVpcFlowLogsServiceClient( + credentials=creds1, + transport=transport_name, + ) + client2 = OrganizationVpcFlowLogsServiceClient( + credentials=creds2, + transport=transport_name, + ) + session1 = client1.transport.list_vpc_flow_logs_configs._session + session2 = client2.transport.list_vpc_flow_logs_configs._session + assert session1 != session2 + session1 = client1.transport.get_vpc_flow_logs_config._session + session2 = client2.transport.get_vpc_flow_logs_config._session + assert session1 != session2 + session1 = client1.transport.create_vpc_flow_logs_config._session + session2 = client2.transport.create_vpc_flow_logs_config._session + assert session1 != session2 + session1 = client1.transport.update_vpc_flow_logs_config._session + session2 = client2.transport.update_vpc_flow_logs_config._session + assert session1 != session2 + session1 = client1.transport.delete_vpc_flow_logs_config._session + session2 = client2.transport.delete_vpc_flow_logs_config._session + assert session1 != session2 + + +def test_organization_vpc_flow_logs_service_grpc_transport_channel(): + channel = grpc.secure_channel("http://localhost/", grpc.local_channel_credentials()) + + # Check that channel is used if provided. + transport = transports.OrganizationVpcFlowLogsServiceGrpcTransport( + host="squid.clam.whelk", + channel=channel, + ) + assert transport.grpc_channel == channel + assert transport._host == "squid.clam.whelk:443" + assert transport._ssl_channel_credentials == None + + +def test_organization_vpc_flow_logs_service_grpc_asyncio_transport_channel(): + channel = aio.secure_channel("http://localhost/", grpc.local_channel_credentials()) + + # Check that channel is used if provided. + transport = transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport( + host="squid.clam.whelk", + channel=channel, + ) + assert transport.grpc_channel == channel + assert transport._host == "squid.clam.whelk:443" + assert transport._ssl_channel_credentials == None + + +# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are +# removed from grpc/grpc_asyncio transport constructor. +@pytest.mark.parametrize( + "transport_class", + [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + ], +) +def test_organization_vpc_flow_logs_service_transport_channel_mtls_with_client_cert_source( + transport_class, +): + with mock.patch( + "grpc.ssl_channel_credentials", autospec=True + ) as grpc_ssl_channel_cred: + with mock.patch.object( + transport_class, "create_channel" + ) as grpc_create_channel: + mock_ssl_cred = mock.Mock() + grpc_ssl_channel_cred.return_value = mock_ssl_cred + + mock_grpc_channel = mock.Mock() + grpc_create_channel.return_value = mock_grpc_channel + + cred = ga_credentials.AnonymousCredentials() + with pytest.warns(DeprecationWarning): + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (cred, None) + transport = transport_class( + host="squid.clam.whelk", + api_mtls_endpoint="mtls.squid.clam.whelk", + client_cert_source=client_cert_source_callback, + ) + adc.assert_called_once() + + grpc_ssl_channel_cred.assert_called_once_with( + certificate_chain=b"cert bytes", private_key=b"key bytes" + ) + grpc_create_channel.assert_called_once_with( + "mtls.squid.clam.whelk:443", + credentials=cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_cred, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + assert transport.grpc_channel == mock_grpc_channel + assert transport._ssl_channel_credentials == mock_ssl_cred + + +# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are +# removed from grpc/grpc_asyncio transport constructor. +@pytest.mark.parametrize( + "transport_class", + [ + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + ], +) +def test_organization_vpc_flow_logs_service_transport_channel_mtls_with_adc( + transport_class, +): + mock_ssl_cred = mock.Mock() + with mock.patch.multiple( + "google.auth.transport.grpc.SslCredentials", + __init__=mock.Mock(return_value=None), + ssl_credentials=mock.PropertyMock(return_value=mock_ssl_cred), + ): + with mock.patch.object( + transport_class, "create_channel" + ) as grpc_create_channel: + mock_grpc_channel = mock.Mock() + grpc_create_channel.return_value = mock_grpc_channel + mock_cred = mock.Mock() + + with pytest.warns(DeprecationWarning): + transport = transport_class( + host="squid.clam.whelk", + credentials=mock_cred, + api_mtls_endpoint="mtls.squid.clam.whelk", + client_cert_source=None, + ) + + grpc_create_channel.assert_called_once_with( + "mtls.squid.clam.whelk:443", + credentials=mock_cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_cred, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + assert transport.grpc_channel == mock_grpc_channel + + +def test_organization_vpc_flow_logs_service_grpc_lro_client(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + transport = client.transport + + # Ensure that we have a api-core operations client. + assert isinstance( + transport.operations_client, + operations_v1.OperationsClient, + ) + + # Ensure that subsequent calls to the property send the exact same object. + assert transport.operations_client is transport.operations_client + + +def test_organization_vpc_flow_logs_service_grpc_lro_async_client(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc_asyncio", + ) + transport = client.transport + + # Ensure that we have a api-core operations client. + assert isinstance( + transport.operations_client, + operations_v1.OperationsAsyncClient, + ) + + # Ensure that subsequent calls to the property send the exact same object. + assert transport.operations_client is transport.operations_client + + +def test_vpc_flow_logs_config_path(): + project = "squid" + location = "clam" + vpc_flow_logs_config = "whelk" + expected = "projects/{project}/locations/{location}/vpcFlowLogsConfigs/{vpc_flow_logs_config}".format( + project=project, + location=location, + vpc_flow_logs_config=vpc_flow_logs_config, + ) + actual = OrganizationVpcFlowLogsServiceClient.vpc_flow_logs_config_path( + project, location, vpc_flow_logs_config + ) + assert expected == actual + + +def test_parse_vpc_flow_logs_config_path(): + expected = { + "project": "octopus", + "location": "oyster", + "vpc_flow_logs_config": "nudibranch", + } + path = OrganizationVpcFlowLogsServiceClient.vpc_flow_logs_config_path(**expected) + + # Check that the path construction is reversible. + actual = OrganizationVpcFlowLogsServiceClient.parse_vpc_flow_logs_config_path(path) + assert expected == actual + + +def test_common_billing_account_path(): + billing_account = "cuttlefish" + expected = "billingAccounts/{billing_account}".format( + billing_account=billing_account, + ) + actual = OrganizationVpcFlowLogsServiceClient.common_billing_account_path( + billing_account + ) + assert expected == actual + + +def test_parse_common_billing_account_path(): + expected = { + "billing_account": "mussel", + } + path = OrganizationVpcFlowLogsServiceClient.common_billing_account_path(**expected) + + # Check that the path construction is reversible. + actual = OrganizationVpcFlowLogsServiceClient.parse_common_billing_account_path( + path + ) + assert expected == actual + + +def test_common_folder_path(): + folder = "winkle" + expected = "folders/{folder}".format( + folder=folder, + ) + actual = OrganizationVpcFlowLogsServiceClient.common_folder_path(folder) + assert expected == actual + + +def test_parse_common_folder_path(): + expected = { + "folder": "nautilus", + } + path = OrganizationVpcFlowLogsServiceClient.common_folder_path(**expected) + + # Check that the path construction is reversible. + actual = OrganizationVpcFlowLogsServiceClient.parse_common_folder_path(path) + assert expected == actual + + +def test_common_organization_path(): + organization = "scallop" + expected = "organizations/{organization}".format( + organization=organization, + ) + actual = OrganizationVpcFlowLogsServiceClient.common_organization_path(organization) + assert expected == actual + + +def test_parse_common_organization_path(): + expected = { + "organization": "abalone", + } + path = OrganizationVpcFlowLogsServiceClient.common_organization_path(**expected) + + # Check that the path construction is reversible. + actual = OrganizationVpcFlowLogsServiceClient.parse_common_organization_path(path) + assert expected == actual + + +def test_common_project_path(): + project = "squid" + expected = "projects/{project}".format( + project=project, + ) + actual = OrganizationVpcFlowLogsServiceClient.common_project_path(project) + assert expected == actual + + +def test_parse_common_project_path(): + expected = { + "project": "clam", + } + path = OrganizationVpcFlowLogsServiceClient.common_project_path(**expected) + + # Check that the path construction is reversible. + actual = OrganizationVpcFlowLogsServiceClient.parse_common_project_path(path) + assert expected == actual + + +def test_common_location_path(): + project = "whelk" + location = "octopus" + expected = "projects/{project}/locations/{location}".format( + project=project, + location=location, + ) + actual = OrganizationVpcFlowLogsServiceClient.common_location_path( + project, location + ) + assert expected == actual + + +def test_parse_common_location_path(): + expected = { + "project": "oyster", + "location": "nudibranch", + } + path = OrganizationVpcFlowLogsServiceClient.common_location_path(**expected) + + # Check that the path construction is reversible. + actual = OrganizationVpcFlowLogsServiceClient.parse_common_location_path(path) + assert expected == actual + + +def test_client_with_default_client_info(): + client_info = gapic_v1.client_info.ClientInfo() + + with mock.patch.object( + transports.OrganizationVpcFlowLogsServiceTransport, "_prep_wrapped_messages" + ) as prep: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, + ) + prep.assert_called_once_with(client_info) + + with mock.patch.object( + transports.OrganizationVpcFlowLogsServiceTransport, "_prep_wrapped_messages" + ) as prep: + transport_class = OrganizationVpcFlowLogsServiceClient.get_transport_class() + transport = transport_class( + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, + ) + prep.assert_called_once_with(client_info) + + +def test_delete_operation(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.DeleteOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_delete_operation_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.DeleteOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_operation_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.DeleteOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + call.return_value = None + + client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_operation_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.DeleteOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_delete_operation_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + + response = client.delete_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_delete_operation_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_cancel_operation(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.CancelOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_cancel_operation_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.CancelOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_cancel_operation_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.CancelOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + call.return_value = None + + client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_cancel_operation_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.CancelOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.cancel_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_cancel_operation_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + + response = client.cancel_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_cancel_operation_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.cancel_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.cancel_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_get_operation(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.GetOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation() + response = client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.Operation) + + +@pytest.mark.asyncio +async def test_get_operation_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.GetOperationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation() + ) + response = await client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.Operation) + + +def test_get_operation_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.GetOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + call.return_value = operations_pb2.Operation() + + client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_operation_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.GetOperationRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation() + ) + await client.get_operation(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_get_operation_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation() + + response = client.get_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_get_operation_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_operation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation() + ) + response = await client.get_operation( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_list_operations(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = operations_pb2.ListOperationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.ListOperationsResponse() + response = client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.ListOperationsResponse) + + +@pytest.mark.asyncio +async def test_list_operations_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = operations_pb2.ListOperationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.ListOperationsResponse() + ) + response = await client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, operations_pb2.ListOperationsResponse) + + +def test_list_operations_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.ListOperationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + call.return_value = operations_pb2.ListOperationsResponse() + + client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_operations_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = operations_pb2.ListOperationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.ListOperationsResponse() + ) + await client.list_operations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_list_operations_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.ListOperationsResponse() + + response = client.list_operations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_list_operations_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_operations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.ListOperationsResponse() + ) + response = await client.list_operations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_list_locations(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = locations_pb2.ListLocationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.ListLocationsResponse() + response = client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.ListLocationsResponse) + + +@pytest.mark.asyncio +async def test_list_locations_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = locations_pb2.ListLocationsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.ListLocationsResponse() + ) + response = await client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.ListLocationsResponse) + + +def test_list_locations_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.ListLocationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + call.return_value = locations_pb2.ListLocationsResponse() + + client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_locations_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.ListLocationsRequest() + request.name = "locations" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.ListLocationsResponse() + ) + await client.list_locations(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations", + ) in kw["metadata"] + + +def test_list_locations_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.ListLocationsResponse() + + response = client.list_locations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_list_locations_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.ListLocationsResponse() + ) + response = await client.list_locations( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_get_location(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = locations_pb2.GetLocationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.Location() + response = client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.Location) + + +@pytest.mark.asyncio +async def test_get_location_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = locations_pb2.GetLocationRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.Location() + ) + response = await client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, locations_pb2.Location) + + +def test_get_location_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials() + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.GetLocationRequest() + request.name = "locations/abc" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + call.return_value = locations_pb2.Location() + + client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations/abc", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_location_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials() + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = locations_pb2.GetLocationRequest() + request.name = "locations/abc" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_location), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.Location() + ) + await client.get_location(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=locations/abc", + ) in kw["metadata"] + + +def test_get_location_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = locations_pb2.Location() + + response = client.get_location( + request={ + "name": "locations/abc", + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_get_location_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_locations), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + locations_pb2.Location() + ) + response = await client.get_location( + request={ + "name": "locations", + } + ) + call.assert_called() + + +def test_set_iam_policy(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = iam_policy_pb2.SetIamPolicyRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + response = client.set_iam_policy(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + + assert response.version == 774 + + assert response.etag == b"etag_blob" + + +@pytest.mark.asyncio +async def test_set_iam_policy_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = iam_policy_pb2.SetIamPolicyRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + ) + response = await client.set_iam_policy(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + + assert response.version == 774 + + assert response.etag == b"etag_blob" + + +def test_set_iam_policy_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.SetIamPolicyRequest() + request.resource = "resource/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + call.return_value = policy_pb2.Policy() + + client.set_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource/value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_set_iam_policy_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.SetIamPolicyRequest() + request.resource = "resource/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + + await client.set_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource/value", + ) in kw["metadata"] + + +def test_set_iam_policy_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + + response = client.set_iam_policy( + request={ + "resource": "resource_value", + "policy": policy_pb2.Policy(version=774), + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_set_iam_policy_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + + response = await client.set_iam_policy( + request={ + "resource": "resource_value", + "policy": policy_pb2.Policy(version=774), + } + ) + call.assert_called() + + +def test_get_iam_policy(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = iam_policy_pb2.GetIamPolicyRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + + response = client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + + assert response.version == 774 + + assert response.etag == b"etag_blob" + + +@pytest.mark.asyncio +async def test_get_iam_policy_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = iam_policy_pb2.GetIamPolicyRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + ) + + response = await client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + + assert response.version == 774 + + assert response.etag == b"etag_blob" + + +def test_get_iam_policy_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.GetIamPolicyRequest() + request.resource = "resource/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + call.return_value = policy_pb2.Policy() + + client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource/value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_iam_policy_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.GetIamPolicyRequest() + request.resource = "resource/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + + await client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource/value", + ) in kw["metadata"] + + +def test_get_iam_policy_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + + response = client.get_iam_policy( + request={ + "resource": "resource_value", + "options": options_pb2.GetPolicyOptions(requested_policy_version=2598), + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_get_iam_policy_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + + response = await client.get_iam_policy( + request={ + "resource": "resource_value", + "options": options_pb2.GetPolicyOptions(requested_policy_version=2598), + } + ) + call.assert_called() + + +def test_test_iam_permissions(transport: str = "grpc"): + client = OrganizationVpcFlowLogsServiceClient( + 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 = iam_policy_pb2.TestIamPermissionsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = iam_policy_pb2.TestIamPermissionsResponse( + permissions=["permissions_value"], + ) + + response = client.test_iam_permissions(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse) + + assert response.permissions == ["permissions_value"] + + +@pytest.mark.asyncio +async def test_test_iam_permissions_async(transport: str = "grpc_asyncio"): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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 = iam_policy_pb2.TestIamPermissionsRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + iam_policy_pb2.TestIamPermissionsResponse( + permissions=["permissions_value"], + ) + ) + + response = await client.test_iam_permissions(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse) + + assert response.permissions == ["permissions_value"] + + +def test_test_iam_permissions_field_headers(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.TestIamPermissionsRequest() + request.resource = "resource/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + call.return_value = iam_policy_pb2.TestIamPermissionsResponse() + + client.test_iam_permissions(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource/value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_test_iam_permissions_field_headers_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.TestIamPermissionsRequest() + request.resource = "resource/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + iam_policy_pb2.TestIamPermissionsResponse() + ) + + await client.test_iam_permissions(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource/value", + ) in kw["metadata"] + + +def test_test_iam_permissions_from_dict(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = iam_policy_pb2.TestIamPermissionsResponse() + + response = client.test_iam_permissions( + request={ + "resource": "resource_value", + "permissions": ["permissions_value"], + } + ) + call.assert_called() + + +@pytest.mark.asyncio +async def test_test_iam_permissions_from_dict_async(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + iam_policy_pb2.TestIamPermissionsResponse() + ) + + response = await client.test_iam_permissions( + request={ + "resource": "resource_value", + "permissions": ["permissions_value"], + } + ) + call.assert_called() + + +def test_transport_close_grpc(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc" + ) + with mock.patch.object( + type(getattr(client.transport, "_grpc_channel")), "close" + ) as close: + with client: + close.assert_not_called() + close.assert_called_once() + + +@pytest.mark.asyncio +async def test_transport_close_grpc_asyncio(): + client = OrganizationVpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), transport="grpc_asyncio" + ) + with mock.patch.object( + type(getattr(client.transport, "_grpc_channel")), "close" + ) as close: + async with client: + close.assert_not_called() + close.assert_called_once() + + +def test_transport_close_rest(): + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + with mock.patch.object( + type(getattr(client.transport, "_session")), "close" + ) as close: + with client: + close.assert_not_called() + close.assert_called_once() + + +def test_client_ctx(): + transports = [ + "rest", + "grpc", + ] + for transport in transports: + client = OrganizationVpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport + ) + # Test client calls underlying transport. + with mock.patch.object(type(client.transport), "close") as close: + close.assert_not_called() + with client: + pass + close.assert_called() + + +@pytest.mark.parametrize( + "client_class,transport_class", + [ + ( + OrganizationVpcFlowLogsServiceClient, + transports.OrganizationVpcFlowLogsServiceGrpcTransport, + ), + ( + OrganizationVpcFlowLogsServiceAsyncClient, + transports.OrganizationVpcFlowLogsServiceGrpcAsyncIOTransport, + ), + ], +) +def test_api_key_credentials(client_class, transport_class): + with mock.patch.object( + google.auth._default, "get_api_key_credentials", create=True + ) as get_api_key_credentials: + mock_cred = mock.Mock() + get_api_key_credentials.return_value = mock_cred + options = client_options.ClientOptions() + options.api_key = "api_key" + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + patched.assert_called_once_with( + credentials=mock_cred, + credentials_file=None, + host=client._DEFAULT_ENDPOINT_TEMPLATE.format( + UNIVERSE_DOMAIN=client._DEFAULT_UNIVERSE + ), + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + api_audience=None, + ) diff --git a/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_reachability_service.py b/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_reachability_service.py index 4335c9c41915..a5bb09959240 100644 --- a/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_reachability_service.py +++ b/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_reachability_service.py @@ -5446,6 +5446,8 @@ def test_create_connectivity_test_rest_call_success(request_type): ], "service_account": "service_account_value", "psc_network_attachment_uri": "psc_network_attachment_uri_value", + "running": True, + "status": 1, }, "firewall": { "display_name": "display_name_value", @@ -5465,6 +5467,8 @@ def test_create_connectivity_test_rest_call_success(request_type): "policy": "policy_value", "policy_uri": "policy_uri_value", "firewall_rule_type": 1, + "policy_priority": 1649, + "target_type": 1, }, "route": { "route_type": 1, @@ -5519,6 +5523,11 @@ def test_create_connectivity_test_rest_call_success(request_type): "psc_service_attachment_uri": "psc_service_attachment_uri_value", "psc_google_api_target": "psc_google_api_target_value", }, + "hybrid_subnet": { + "display_name": "display_name_value", + "uri": "uri_value", + "region": "region_value", + }, "vpn_gateway": { "display_name": "display_name_value", "uri": "uri_value", @@ -5538,6 +5547,15 @@ def test_create_connectivity_test_rest_call_success(request_type): "region": "region_value", "routing_type": 1, }, + "interconnect_attachment": { + "display_name": "display_name_value", + "uri": "uri_value", + "interconnect_uri": "interconnect_uri_value", + "region": "region_value", + "cloud_router_uri": "cloud_router_uri_value", + "type_": 1, + "l2_attachment_matched_ip_address": "l2_attachment_matched_ip_address_value", + }, "vpc_connector": { "display_name": "display_name_value", "uri": "uri_value", @@ -5559,6 +5577,7 @@ def test_create_connectivity_test_rest_call_success(request_type): "ip_address": "ip_address_value", "storage_bucket": "storage_bucket_value", "psc_google_api_target": "psc_google_api_target_value", + "google_service_type": 1, }, "forward": { "target": 1, @@ -5580,6 +5599,8 @@ def test_create_connectivity_test_rest_call_success(request_type): "source_ip": "source_ip_value", "destination_ip": "destination_ip_value", "region": "region_value", + "source_geolocation_code": "source_geolocation_code_value", + "destination_geolocation_code": "destination_geolocation_code_value", }, "load_balancer": { "load_balancer_type": 1, @@ -5720,6 +5741,17 @@ def test_create_connectivity_test_rest_call_success(request_type): "destination_egress_location": { "metropolitan_area": "metropolitan_area_value" }, + "edge_responses": [ + { + "result": 1, + "sent_probe_count": 1721, + "successful_probe_count": 2367, + "probing_latency": {}, + "destination_egress_location": {}, + "destination_router": "destination_router_value", + } + ], + "probed_all_devices": True, }, "round_trip": True, "return_reachability_details": {}, @@ -6001,6 +6033,8 @@ def test_update_connectivity_test_rest_call_success(request_type): ], "service_account": "service_account_value", "psc_network_attachment_uri": "psc_network_attachment_uri_value", + "running": True, + "status": 1, }, "firewall": { "display_name": "display_name_value", @@ -6020,6 +6054,8 @@ def test_update_connectivity_test_rest_call_success(request_type): "policy": "policy_value", "policy_uri": "policy_uri_value", "firewall_rule_type": 1, + "policy_priority": 1649, + "target_type": 1, }, "route": { "route_type": 1, @@ -6074,6 +6110,11 @@ def test_update_connectivity_test_rest_call_success(request_type): "psc_service_attachment_uri": "psc_service_attachment_uri_value", "psc_google_api_target": "psc_google_api_target_value", }, + "hybrid_subnet": { + "display_name": "display_name_value", + "uri": "uri_value", + "region": "region_value", + }, "vpn_gateway": { "display_name": "display_name_value", "uri": "uri_value", @@ -6093,6 +6134,15 @@ def test_update_connectivity_test_rest_call_success(request_type): "region": "region_value", "routing_type": 1, }, + "interconnect_attachment": { + "display_name": "display_name_value", + "uri": "uri_value", + "interconnect_uri": "interconnect_uri_value", + "region": "region_value", + "cloud_router_uri": "cloud_router_uri_value", + "type_": 1, + "l2_attachment_matched_ip_address": "l2_attachment_matched_ip_address_value", + }, "vpc_connector": { "display_name": "display_name_value", "uri": "uri_value", @@ -6114,6 +6164,7 @@ def test_update_connectivity_test_rest_call_success(request_type): "ip_address": "ip_address_value", "storage_bucket": "storage_bucket_value", "psc_google_api_target": "psc_google_api_target_value", + "google_service_type": 1, }, "forward": { "target": 1, @@ -6135,6 +6186,8 @@ def test_update_connectivity_test_rest_call_success(request_type): "source_ip": "source_ip_value", "destination_ip": "destination_ip_value", "region": "region_value", + "source_geolocation_code": "source_geolocation_code_value", + "destination_geolocation_code": "destination_geolocation_code_value", }, "load_balancer": { "load_balancer_type": 1, @@ -6275,6 +6328,17 @@ def test_update_connectivity_test_rest_call_success(request_type): "destination_egress_location": { "metropolitan_area": "metropolitan_area_value" }, + "edge_responses": [ + { + "result": 1, + "sent_probe_count": 1721, + "successful_probe_count": 2367, + "probing_latency": {}, + "destination_egress_location": {}, + "destination_router": "destination_router_value", + } + ], + "probed_all_devices": True, }, "round_trip": True, "return_reachability_details": {}, diff --git a/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_vpc_flow_logs_service.py b/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_vpc_flow_logs_service.py index 21c693ca8f3e..fca1567cf62f 100644 --- a/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_vpc_flow_logs_service.py +++ b/packages/google-cloud-network-management/tests/unit/gapic/network_management_v1/test_vpc_flow_logs_service.py @@ -1765,8 +1765,9 @@ def test_get_vpc_flow_logs_config(request_type, transport: str = "grpc"): metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, metadata_fields=["metadata_fields_value"], filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, - interconnect_attachment="interconnect_attachment_value", + network="network_value", ) response = client.get_vpc_flow_logs_config(request) @@ -1792,6 +1793,10 @@ def test_get_vpc_flow_logs_config(request_type, transport: str = "grpc"): ) assert response.metadata_fields == ["metadata_fields_value"] assert response.filter_expr == "filter_expr_value" + assert ( + response.cross_project_metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED + ) assert ( response.target_resource_state == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS @@ -1939,6 +1944,7 @@ async def test_get_vpc_flow_logs_config_async( metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, metadata_fields=["metadata_fields_value"], filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, ) ) @@ -1966,6 +1972,10 @@ async def test_get_vpc_flow_logs_config_async( ) assert response.metadata_fields == ["metadata_fields_value"] assert response.filter_expr == "filter_expr_value" + assert ( + response.cross_project_metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED + ) assert ( response.target_resource_state == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS @@ -3213,13 +3223,87 @@ async def test_delete_vpc_flow_logs_config_flattened_error_async(): ) -def test_list_vpc_flow_logs_configs_rest_use_cached_wrapped_rpc(): +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, + dict, + ], +) +def test_query_org_vpc_flow_logs_configs(request_type, transport: str = "grpc"): + client = VpcFlowLogsServiceClient( + 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.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + response = client.query_org_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.QueryOrgVpcFlowLogsConfigsPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +def test_query_org_vpc_flow_logs_configs_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.query_org_vpc_flow_logs_configs(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest( + parent="parent_value", + page_token="page_token_value", + filter="filter_value", + ) + + +def test_query_org_vpc_flow_logs_configs_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -3228,7 +3312,7 @@ def test_list_vpc_flow_logs_configs_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_vpc_flow_logs_configs + client._transport.query_org_vpc_flow_logs_configs in client._transport._wrapped_methods ) @@ -3238,156 +3322,1496 @@ def test_list_vpc_flow_logs_configs_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_vpc_flow_logs_configs + client._transport.query_org_vpc_flow_logs_configs ] = mock_rpc - request = {} - client.list_vpc_flow_logs_configs(request) + client.query_org_vpc_flow_logs_configs(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_vpc_flow_logs_configs(request) + client.query_org_vpc_flow_logs_configs(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_list_vpc_flow_logs_configs_rest_required_fields( - request_type=vpc_flow_logs.ListVpcFlowLogsConfigsRequest, +@pytest.mark.asyncio +async def test_query_org_vpc_flow_logs_configs_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.VpcFlowLogsServiceRestTransport + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) - ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # verify fields with default values are dropped + # Ensure method has been cached + assert ( + client._client._transport.query_org_vpc_flow_logs_configs + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_vpc_flow_logs_configs._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.query_org_vpc_flow_logs_configs + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.query_org_vpc_flow_logs_configs(request) - jsonified_request["parent"] = "parent_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_vpc_flow_logs_configs._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "filter", - "order_by", - "page_size", - "page_token", - ) - ) - jsonified_request.update(unset_fields) + await client.query_org_vpc_flow_logs_configs(request) - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - client = VpcFlowLogsServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_query_org_vpc_flow_logs_configs_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, +): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "get", - "query_params": pb_request, - } - transcode.return_value = transcode_result + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() - response_value = Response() - response_value.status_code = 200 + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + ) + response = await client.query_org_vpc_flow_logs_configs(request) - # Convert return value to protobuf type - return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() + assert args[0] == request - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.QueryOrgVpcFlowLogsConfigsAsyncPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] - response = client.list_vpc_flow_logs_configs(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params +@pytest.mark.asyncio +async def test_query_org_vpc_flow_logs_configs_async_from_dict(): + await test_query_org_vpc_flow_logs_configs_async(request_type=dict) -def test_list_vpc_flow_logs_configs_rest_unset_required_fields(): - transport = transports.VpcFlowLogsServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_query_org_vpc_flow_logs_configs_field_headers(): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.list_vpc_flow_logs_configs._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "orderBy", - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() + request.parent = "parent_value" -def test_list_vpc_flow_logs_configs_rest_flattened(): - client = VpcFlowLogsServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() + client.query_org_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_query_org_vpc_flow_logs_configs_field_headers_async(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - # 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 = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + request.parent = "parent_value" - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() ) - mock_args.update(sample_request) + await client.query_org_vpc_flow_logs_configs(request) - # Wrap the value into a proper Response obj + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_query_org_vpc_flow_logs_configs_pager(transport_name: str = "grpc"): + client = VpcFlowLogsServiceClient( + 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.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.query_org_vpc_flow_logs_configs( + request={}, retry=retry, timeout=timeout + ) + + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.VpcFlowLogsConfig) for i in results + ) + + +def test_query_org_vpc_flow_logs_configs_pages(transport_name: str = "grpc"): + client = VpcFlowLogsServiceClient( + 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.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + pages = list(client.query_org_vpc_flow_logs_configs(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_query_org_vpc_flow_logs_configs_async_pager(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + async_pager = await client.query_org_vpc_flow_logs_configs( + 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, vpc_flow_logs_config.VpcFlowLogsConfig) for i in responses + ) + + +@pytest.mark.asyncio +async def test_query_org_vpc_flow_logs_configs_async_pages(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + 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.query_org_vpc_flow_logs_configs(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", + [ + vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, + dict, + ], +) +def test_show_effective_flow_logs_configs(request_type, transport: str = "grpc"): + client = VpcFlowLogsServiceClient( + 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.show_effective_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + response = client.show_effective_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ShowEffectiveFlowLogsConfigsPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +def test_show_effective_flow_logs_configs_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest( + parent="parent_value", + resource="resource_value", + page_token="page_token_value", + filter="filter_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.show_effective_flow_logs_configs(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest( + parent="parent_value", + resource="resource_value", + page_token="page_token_value", + filter="filter_value", + ) + + +def test_show_effective_flow_logs_configs_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.show_effective_flow_logs_configs + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.show_effective_flow_logs_configs + ] = mock_rpc + request = {} + client.show_effective_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.show_effective_flow_logs_configs(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_show_effective_flow_logs_configs_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.show_effective_flow_logs_configs + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.show_effective_flow_logs_configs + ] = mock_rpc + + request = {} + await client.show_effective_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.show_effective_flow_logs_configs(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_show_effective_flow_logs_configs_async( + transport: str = "grpc_asyncio", + request_type=vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, +): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + 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.show_effective_flow_logs_configs), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + ) + response = await client.show_effective_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ShowEffectiveFlowLogsConfigsAsyncPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +@pytest.mark.asyncio +async def test_show_effective_flow_logs_configs_async_from_dict(): + await test_show_effective_flow_logs_configs_async(request_type=dict) + + +def test_show_effective_flow_logs_configs_field_headers(): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), "__call__" + ) as call: + call.return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() + client.show_effective_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_show_effective_flow_logs_configs_field_headers_async(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() + ) + await client.show_effective_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_show_effective_flow_logs_configs_pager(transport_name: str = "grpc"): + client = VpcFlowLogsServiceClient( + 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.show_effective_flow_logs_configs), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.show_effective_flow_logs_configs( + request={}, retry=retry, timeout=timeout + ) + + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.EffectiveVpcFlowLogsConfig) + for i in results + ) + + +def test_show_effective_flow_logs_configs_pages(transport_name: str = "grpc"): + client = VpcFlowLogsServiceClient( + 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.show_effective_flow_logs_configs), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + pages = list(client.show_effective_flow_logs_configs(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_show_effective_flow_logs_configs_async_pager(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + ), + RuntimeError, + ) + async_pager = await client.show_effective_flow_logs_configs( + 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, vpc_flow_logs_config.EffectiveVpcFlowLogsConfig) + for i in responses + ) + + +@pytest.mark.asyncio +async def test_show_effective_flow_logs_configs_async_pages(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + ), + 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.show_effective_flow_logs_configs(request={}) + ).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_list_vpc_flow_logs_configs_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.list_vpc_flow_logs_configs + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.list_vpc_flow_logs_configs + ] = mock_rpc + + request = {} + client.list_vpc_flow_logs_configs(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_vpc_flow_logs_configs(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_list_vpc_flow_logs_configs_rest_required_fields( + request_type=vpc_flow_logs.ListVpcFlowLogsConfigsRequest, +): + transport_class = transports.VpcFlowLogsServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_vpc_flow_logs_configs._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_vpc_flow_logs_configs._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.list_vpc_flow_logs_configs(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_vpc_flow_logs_configs_rest_unset_required_fields(): + transport = transports.VpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_vpc_flow_logs_configs._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_vpc_flow_logs_configs_rest_flattened(): + client = VpcFlowLogsServiceClient( + 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 = vpc_flow_logs.ListVpcFlowLogsConfigsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.list_vpc_flow_logs_configs(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}/vpcFlowLogsConfigs" + % client.transport._host, + args[1], + ) + + +def test_list_vpc_flow_logs_configs_rest_flattened_error(transport: str = "rest"): + client = VpcFlowLogsServiceClient( + 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_vpc_flow_logs_configs( + vpc_flow_logs.ListVpcFlowLogsConfigsRequest(), + parent="parent_value", + ) + + +def test_list_vpc_flow_logs_configs_rest_pager(transport: str = "rest"): + client = VpcFlowLogsServiceClient( + 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 = ( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ListVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + vpc_flow_logs.ListVpcFlowLogsConfigsResponse.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"} + + pager = client.list_vpc_flow_logs_configs(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.VpcFlowLogsConfig) for i in results + ) + + pages = list(client.list_vpc_flow_logs_configs(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.get_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.get_vpc_flow_logs_config + ] = mock_rpc + + request = {} + client.get_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_get_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.GetVpcFlowLogsConfigRequest, +): + transport_class = transports.VpcFlowLogsServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_vpc_flow_logs_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_vpc_flow_logs_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 = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_vpc_flow_logs_config(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_vpc_flow_logs_config_rest_unset_required_fields(): + transport = transports.VpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_vpc_flow_logs_config_rest_flattened(): + client = VpcFlowLogsServiceClient( + 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 = vpc_flow_logs_config.VpcFlowLogsConfig() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.get_vpc_flow_logs_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/v1/{name=projects/*/locations/*/vpcFlowLogsConfigs/*}" + % client.transport._host, + args[1], + ) + + +def test_get_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): + client = VpcFlowLogsServiceClient( + 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_vpc_flow_logs_config( + vpc_flow_logs.GetVpcFlowLogsConfigRequest(), + name="name_value", + ) + + +def test_create_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.create_vpc_flow_logs_config + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.create_vpc_flow_logs_config + ] = mock_rpc + + request = {} + client.create_vpc_flow_logs_config(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.create_vpc_flow_logs_config(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_create_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +): + transport_class = transports.VpcFlowLogsServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request_init["vpc_flow_logs_config_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + assert "vpcFlowLogsConfigId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "vpcFlowLogsConfigId" in jsonified_request + assert ( + jsonified_request["vpcFlowLogsConfigId"] + == request_init["vpc_flow_logs_config_id"] + ) + + jsonified_request["parent"] = "parent_value" + jsonified_request["vpcFlowLogsConfigId"] = "vpc_flow_logs_config_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("vpc_flow_logs_config_id",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "vpcFlowLogsConfigId" in jsonified_request + assert jsonified_request["vpcFlowLogsConfigId"] == "vpc_flow_logs_config_id_value" + + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.create_vpc_flow_logs_config(request) + + expected_params = [ + ( + "vpcFlowLogsConfigId", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_vpc_flow_logs_config_rest_unset_required_fields(): + transport = transports.VpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("vpcFlowLogsConfigId",)) + & set( + ( + "parent", + "vpcFlowLogsConfigId", + "vpcFlowLogsConfig", + ) + ) + ) + + +def test_create_vpc_flow_logs_config_rest_flattened(): + client = VpcFlowLogsServiceClient( + 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 = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = vpc_flow_logs.ListVpcFlowLogsConfigsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.list_vpc_flow_logs_configs(**mock_args) + client.create_vpc_flow_logs_config(**mock_args) # Establish that the underlying call was made with the expected # request object values. @@ -3400,7 +4824,7 @@ def test_list_vpc_flow_logs_configs_rest_flattened(): ) -def test_list_vpc_flow_logs_configs_rest_flattened_error(transport: str = "rest"): +def test_create_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -3409,78 +4833,17 @@ def test_list_vpc_flow_logs_configs_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_vpc_flow_logs_configs( - vpc_flow_logs.ListVpcFlowLogsConfigsRequest(), + client.create_vpc_flow_logs_config( + vpc_flow_logs.CreateVpcFlowLogsConfigRequest(), parent="parent_value", - ) - - -def test_list_vpc_flow_logs_configs_rest_pager(transport: str = "rest"): - client = VpcFlowLogsServiceClient( - 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 = ( - vpc_flow_logs.ListVpcFlowLogsConfigsResponse( - vpc_flow_logs_configs=[ - vpc_flow_logs_config.VpcFlowLogsConfig(), - vpc_flow_logs_config.VpcFlowLogsConfig(), - vpc_flow_logs_config.VpcFlowLogsConfig(), - ], - next_page_token="abc", - ), - vpc_flow_logs.ListVpcFlowLogsConfigsResponse( - vpc_flow_logs_configs=[], - next_page_token="def", - ), - vpc_flow_logs.ListVpcFlowLogsConfigsResponse( - vpc_flow_logs_configs=[ - vpc_flow_logs_config.VpcFlowLogsConfig(), - ], - next_page_token="ghi", - ), - vpc_flow_logs.ListVpcFlowLogsConfigsResponse( - vpc_flow_logs_configs=[ - vpc_flow_logs_config.VpcFlowLogsConfig(), - vpc_flow_logs_config.VpcFlowLogsConfig(), - ], + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" ), + vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - vpc_flow_logs.ListVpcFlowLogsConfigsResponse.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"} - - pager = client.list_vpc_flow_logs_configs(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all( - isinstance(i, vpc_flow_logs_config.VpcFlowLogsConfig) for i in results - ) - - pages = list(client.list_vpc_flow_logs_configs(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_get_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): +def test_update_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -3495,7 +4858,7 @@ def test_get_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_vpc_flow_logs_config + client._transport.update_vpc_flow_logs_config in client._transport._wrapped_methods ) @@ -3505,29 +4868,32 @@ def test_get_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_vpc_flow_logs_config + client._transport.update_vpc_flow_logs_config ] = mock_rpc request = {} - client.get_vpc_flow_logs_config(request) + client.update_vpc_flow_logs_config(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_vpc_flow_logs_config(request) + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.update_vpc_flow_logs_config(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_get_vpc_flow_logs_config_rest_required_fields( - request_type=vpc_flow_logs.GetVpcFlowLogsConfigRequest, +def test_update_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, ): transport_class = transports.VpcFlowLogsServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -3538,21 +4904,19 @@ def test_get_vpc_flow_logs_config_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).update_vpc_flow_logs_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" + # verify required fields with default values are now present unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).update_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3561,7 +4925,7 @@ def test_get_vpc_flow_logs_config_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + return_value = operations_pb2.Operation(name="operations/spam") # 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 @@ -3573,39 +4937,45 @@ def test_get_vpc_flow_logs_config_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "patch", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.get_vpc_flow_logs_config(request) + response = client.update_vpc_flow_logs_config(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_vpc_flow_logs_config_rest_unset_required_fields(): +def test_update_vpc_flow_logs_config_rest_unset_required_fields(): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_vpc_flow_logs_config._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.update_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "updateMask", + "vpcFlowLogsConfig", + ) + ) + ) -def test_get_vpc_flow_logs_config_rest_flattened(): +def test_update_vpc_flow_logs_config_rest_flattened(): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -3614,43 +4984,46 @@ def test_get_vpc_flow_logs_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 = vpc_flow_logs_config.VpcFlowLogsConfig() + return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + "vpc_flow_logs_config": { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } } # get truthy value for each flattened field mock_args = dict( - name="name_value", + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_vpc_flow_logs_config(**mock_args) + client.update_vpc_flow_logs_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/v1/{name=projects/*/locations/*/vpcFlowLogsConfigs/*}" + "%s/v1/{vpc_flow_logs_config.name=projects/*/locations/*/vpcFlowLogsConfigs/*}" % client.transport._host, args[1], ) -def test_get_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): +def test_update_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -3659,13 +5032,16 @@ def test_get_vpc_flow_logs_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_vpc_flow_logs_config( - vpc_flow_logs.GetVpcFlowLogsConfigRequest(), - name="name_value", + client.update_vpc_flow_logs_config( + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(), + vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_create_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): +def test_delete_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -3680,7 +5056,7 @@ def test_create_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_vpc_flow_logs_config + client._transport.delete_vpc_flow_logs_config in client._transport._wrapped_methods ) @@ -3690,11 +5066,11 @@ def test_create_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_vpc_flow_logs_config + client._transport.delete_vpc_flow_logs_config ] = mock_rpc request = {} - client.create_vpc_flow_logs_config(request) + client.delete_vpc_flow_logs_config(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 @@ -3703,21 +5079,20 @@ def test_create_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # subsequent calls should use the cached wrapper wrapper_fn.reset_mock() - client.create_vpc_flow_logs_config(request) + client.delete_vpc_flow_logs_config(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_vpc_flow_logs_config_rest_required_fields( - request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +def test_delete_vpc_flow_logs_config_rest_required_fields( + request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, ): transport_class = transports.VpcFlowLogsServiceRestTransport request_init = {} - request_init["parent"] = "" - request_init["vpc_flow_logs_config_id"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -3725,35 +5100,24 @@ def test_create_vpc_flow_logs_config_rest_required_fields( ) # verify fields with default values are dropped - assert "vpcFlowLogsConfigId" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).delete_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "vpcFlowLogsConfigId" in jsonified_request - assert ( - jsonified_request["vpcFlowLogsConfigId"] - == request_init["vpc_flow_logs_config_id"] - ) - jsonified_request["parent"] = "parent_value" - jsonified_request["vpcFlowLogsConfigId"] = "vpc_flow_logs_config_id_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("vpc_flow_logs_config_id",)) + ).delete_vpc_flow_logs_config._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 "vpcFlowLogsConfigId" in jsonified_request - assert jsonified_request["vpcFlowLogsConfigId"] == "vpc_flow_logs_config_id_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3774,10 +5138,9 @@ def test_create_vpc_flow_logs_config_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() @@ -3788,38 +5151,23 @@ def test_create_vpc_flow_logs_config_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.create_vpc_flow_logs_config(request) + response = client.delete_vpc_flow_logs_config(request) - expected_params = [ - ( - "vpcFlowLogsConfigId", - "", - ), - ("$alt", "json;enum-encoding=int"), - ] + expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_vpc_flow_logs_config_rest_unset_required_fields(): +def test_delete_vpc_flow_logs_config_rest_unset_required_fields(): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_vpc_flow_logs_config._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("vpcFlowLogsConfigId",)) - & set( - ( - "parent", - "vpcFlowLogsConfigId", - "vpcFlowLogsConfig", - ) - ) - ) + unset_fields = transport.delete_vpc_flow_logs_config._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_vpc_flow_logs_config_rest_flattened(): +def test_delete_vpc_flow_logs_config_rest_flattened(): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -3831,15 +5179,13 @@ def test_create_vpc_flow_logs_config_rest_flattened(): return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + sample_request = { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( - name="name_value" - ), - vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + name="name_value", ) mock_args.update(sample_request) @@ -3851,20 +5197,20 @@ def test_create_vpc_flow_logs_config_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.create_vpc_flow_logs_config(**mock_args) + client.delete_vpc_flow_logs_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/v1/{parent=projects/*/locations/*}/vpcFlowLogsConfigs" + "%s/v1/{name=projects/*/locations/*/vpcFlowLogsConfigs/*}" % client.transport._host, args[1], ) -def test_create_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): +def test_delete_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -3873,17 +5219,13 @@ def test_create_vpc_flow_logs_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.create_vpc_flow_logs_config( - vpc_flow_logs.CreateVpcFlowLogsConfigRequest(), - parent="parent_value", - vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( - name="name_value" - ), - vpc_flow_logs_config_id="vpc_flow_logs_config_id_value", + client.delete_vpc_flow_logs_config( + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(), + name="name_value", ) -def test_update_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): +def test_query_org_vpc_flow_logs_configs_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -3898,7 +5240,7 @@ def test_update_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_vpc_flow_logs_config + client._transport.query_org_vpc_flow_logs_configs in client._transport._wrapped_methods ) @@ -3908,32 +5250,29 @@ def test_update_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_vpc_flow_logs_config + client._transport.query_org_vpc_flow_logs_configs ] = mock_rpc request = {} - client.update_vpc_flow_logs_config(request) + client.query_org_vpc_flow_logs_configs(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.update_vpc_flow_logs_config(request) + client.query_org_vpc_flow_logs_configs(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_vpc_flow_logs_config_rest_required_fields( - request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, +def test_query_org_vpc_flow_logs_configs_rest_required_fields( + request_type=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, ): transport_class = transports.VpcFlowLogsServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -3944,19 +5283,29 @@ def test_update_vpc_flow_logs_config_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).query_org_vpc_flow_logs_configs._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).query_org_vpc_flow_logs_configs._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",)) + 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 = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3965,7 +5314,7 @@ def test_update_vpc_flow_logs_config_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() # 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 @@ -3977,111 +5326,120 @@ def test_update_vpc_flow_logs_config_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.pb( + return_value + ) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.update_vpc_flow_logs_config(request) + response = client.query_org_vpc_flow_logs_configs(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_vpc_flow_logs_config_rest_unset_required_fields(): +def test_query_org_vpc_flow_logs_configs_rest_unset_required_fields(): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_vpc_flow_logs_config._get_unset_required_fields({}) + unset_fields = transport.query_org_vpc_flow_logs_configs._get_unset_required_fields( + {} + ) assert set(unset_fields) == ( - set(("updateMask",)) - & set( + set( ( - "updateMask", - "vpcFlowLogsConfig", + "filter", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_update_vpc_flow_logs_config_rest_flattened(): +def test_query_org_vpc_flow_logs_configs_rest_pager(transport: str = "rest"): client = VpcFlowLogsServiceClient( 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 = operations_pb2.Operation(name="operations/spam") - - # get arguments that satisfy an http rule for this method - sample_request = { - "vpc_flow_logs_config": { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } - } - - # get truthy value for each flattened field - mock_args = dict( - vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( - 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 = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + vpc_flow_logs_configs=[ + vpc_flow_logs_config.VpcFlowLogsConfig(), + vpc_flow_logs_config.VpcFlowLogsConfig(), + ], ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - - client.update_vpc_flow_logs_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/v1/{vpc_flow_logs_config.name=projects/*/locations/*/vpcFlowLogsConfigs/*}" - % client.transport._host, - args[1], + # Wrap the values into proper Response objs + response = tuple( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.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"} -def test_update_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): - client = VpcFlowLogsServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) + pager = client.query_org_vpc_flow_logs_configs(request=sample_request) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.update_vpc_flow_logs_config( - vpc_flow_logs.UpdateVpcFlowLogsConfigRequest(), - vpc_flow_logs_config=gcn_vpc_flow_logs_config.VpcFlowLogsConfig( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.VpcFlowLogsConfig) for i in results + ) + + pages = list( + client.query_org_vpc_flow_logs_configs(request=sample_request).pages ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_delete_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): +def test_show_effective_flow_logs_configs_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -4096,7 +5454,7 @@ def test_delete_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_vpc_flow_logs_config + client._transport.show_effective_flow_logs_configs in client._transport._wrapped_methods ) @@ -4106,33 +5464,30 @@ def test_delete_vpc_flow_logs_config_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_vpc_flow_logs_config + client._transport.show_effective_flow_logs_configs ] = mock_rpc request = {} - client.delete_vpc_flow_logs_config(request) + client.show_effective_flow_logs_configs(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.delete_vpc_flow_logs_config(request) + client.show_effective_flow_logs_configs(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_vpc_flow_logs_config_rest_required_fields( - request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, +def test_show_effective_flow_logs_configs_rest_required_fields( + request_type=vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, ): transport_class = transports.VpcFlowLogsServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" + request_init["resource"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -4140,24 +5495,39 @@ def test_delete_vpc_flow_logs_config_rest_required_fields( ) # verify fields with default values are dropped + assert "resource" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).show_effective_flow_logs_configs._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "resource" in jsonified_request + assert jsonified_request["resource"] == request_init["resource"] - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" + jsonified_request["resource"] = "resource_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_vpc_flow_logs_config._get_unset_required_fields(jsonified_request) + ).show_effective_flow_logs_configs._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", + "resource", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "resource" in jsonified_request + assert jsonified_request["resource"] == "resource_value" client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4166,7 +5536,7 @@ def test_delete_vpc_flow_logs_config_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() # 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 @@ -4178,91 +5548,130 @@ def test_delete_vpc_flow_logs_config_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "get", "query_params": pb_request, } transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.pb( + return_value + ) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_vpc_flow_logs_config(request) + response = client.show_effective_flow_logs_configs(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "resource", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_vpc_flow_logs_config_rest_unset_required_fields(): +def test_show_effective_flow_logs_configs_rest_unset_required_fields(): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_vpc_flow_logs_config._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = ( + transport.show_effective_flow_logs_configs._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + "resource", + ) + ) + & set( + ( + "parent", + "resource", + ) + ) + ) -def test_delete_vpc_flow_logs_config_rest_flattened(): +def test_show_effective_flow_logs_configs_rest_pager(transport: str = "rest"): client = VpcFlowLogsServiceClient( 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 = operations_pb2.Operation(name="operations/spam") - - # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } + 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 = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="abc", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[], + next_page_token="def", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + next_page_token="ghi", + ), + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + effective_flow_logs_configs=[ + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + vpc_flow_logs_config.EffectiveVpcFlowLogsConfig(), + ], + ), + ) + # Two responses for two calls + response = response + response - # get truthy value for each flattened field - mock_args = dict( - name="name_value", + # Wrap the values into proper Response objs + response = tuple( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.to_json(x) + for x in response ) - mock_args.update(sample_request) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + sample_request = {"parent": "projects/sample1/locations/sample2"} - client.delete_vpc_flow_logs_config(**mock_args) + pager = client.show_effective_flow_logs_configs(request=sample_request) - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/vpcFlowLogsConfigs/*}" - % client.transport._host, - args[1], + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, vpc_flow_logs_config.EffectiveVpcFlowLogsConfig) + for i in results ) - -def test_delete_vpc_flow_logs_config_rest_flattened_error(transport: str = "rest"): - client = VpcFlowLogsServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.delete_vpc_flow_logs_config( - vpc_flow_logs.DeleteVpcFlowLogsConfigRequest(), - name="name_value", + pages = list( + client.show_effective_flow_logs_configs(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(): @@ -4486,6 +5895,52 @@ def test_delete_vpc_flow_logs_config_empty_call_grpc(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_query_org_vpc_flow_logs_configs_empty_call_grpc(): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + call.return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() + client.query_org_vpc_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_show_effective_flow_logs_configs_empty_call_grpc(): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), "__call__" + ) as call: + call.return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() + client.show_effective_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() + + assert args[0] == request_msg + + def test_transport_kind_grpc_asyncio(): transport = VpcFlowLogsServiceAsyncClient.get_transport_class("grpc_asyncio")( credentials=async_anonymous_credentials() @@ -4554,15 +6009,70 @@ async def test_get_vpc_flow_logs_config_empty_call_grpc_asyncio(): metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, metadata_fields=["metadata_fields_value"], filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, ) ) - await client.get_vpc_flow_logs_config(request=None) + await client.get_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_create_vpc_flow_logs_config_empty_call_grpc_asyncio(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.create_vpc_flow_logs_config(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_update_vpc_flow_logs_config_empty_call_grpc_asyncio(): + client = VpcFlowLogsServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_vpc_flow_logs_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.update_vpc_flow_logs_config(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + request_msg = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() assert args[0] == request_msg @@ -4570,7 +6080,7 @@ async def test_get_vpc_flow_logs_config_empty_call_grpc_asyncio(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. @pytest.mark.asyncio -async def test_create_vpc_flow_logs_config_empty_call_grpc_asyncio(): +async def test_delete_vpc_flow_logs_config_empty_call_grpc_asyncio(): client = VpcFlowLogsServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -4578,18 +6088,18 @@ async def test_create_vpc_flow_logs_config_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_vpc_flow_logs_config), "__call__" + type(client.transport.delete_vpc_flow_logs_config), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( operations_pb2.Operation(name="operations/spam") ) - await client.create_vpc_flow_logs_config(request=None) + await client.delete_vpc_flow_logs_config(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + request_msg = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() assert args[0] == request_msg @@ -4597,7 +6107,7 @@ async def test_create_vpc_flow_logs_config_empty_call_grpc_asyncio(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. @pytest.mark.asyncio -async def test_update_vpc_flow_logs_config_empty_call_grpc_asyncio(): +async def test_query_org_vpc_flow_logs_configs_empty_call_grpc_asyncio(): client = VpcFlowLogsServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -4605,18 +6115,21 @@ async def test_update_vpc_flow_logs_config_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_vpc_flow_logs_config), "__call__" + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) ) - await client.update_vpc_flow_logs_config(request=None) + await client.query_org_vpc_flow_logs_configs(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + request_msg = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() assert args[0] == request_msg @@ -4624,7 +6137,7 @@ async def test_update_vpc_flow_logs_config_empty_call_grpc_asyncio(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. @pytest.mark.asyncio -async def test_delete_vpc_flow_logs_config_empty_call_grpc_asyncio(): +async def test_show_effective_flow_logs_configs_empty_call_grpc_asyncio(): client = VpcFlowLogsServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -4632,18 +6145,21 @@ async def test_delete_vpc_flow_logs_config_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_vpc_flow_logs_config), "__call__" + type(client.transport.show_effective_flow_logs_configs), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) ) - await client.delete_vpc_flow_logs_config(request=None) + await client.show_effective_flow_logs_configs(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + request_msg = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() assert args[0] == request_msg @@ -4829,64 +6345,286 @@ def test_get_vpc_flow_logs_config_rest_call_success(request_type): credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) - # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/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 = vpc_flow_logs_config.VpcFlowLogsConfig( + name="name_value", + description="description_value", + state=vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED, + aggregation_interval=vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC, + flow_sampling=0.1394, + metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, + metadata_fields=["metadata_fields_value"], + filter_expr="filter_expr_value", + cross_project_metadata=vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED, + target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, + network="network_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.get_vpc_flow_logs_config(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, vpc_flow_logs_config.VpcFlowLogsConfig) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.state == vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED + assert ( + response.aggregation_interval + == vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC + ) + assert math.isclose(response.flow_sampling, 0.1394, rel_tol=1e-6) + assert ( + response.metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA + ) + assert response.metadata_fields == ["metadata_fields_value"] + assert response.filter_expr == "filter_expr_value" + assert ( + response.cross_project_metadata + == vpc_flow_logs_config.VpcFlowLogsConfig.CrossProjectMetadata.CROSS_PROJECT_METADATA_ENABLED + ) + assert ( + response.target_resource_state + == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_vpc_flow_logs_config_rest_interceptors(null_interceptor): + transport = transports.VpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.VpcFlowLogsServiceRestInterceptor(), + ) + client = VpcFlowLogsServiceClient(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.VpcFlowLogsServiceRestInterceptor, "post_get_vpc_flow_logs_config" + ) as post, mock.patch.object( + transports.VpcFlowLogsServiceRestInterceptor, + "post_get_vpc_flow_logs_config_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.VpcFlowLogsServiceRestInterceptor, "pre_get_vpc_flow_logs_config" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.GetVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.GetVpcFlowLogsConfigRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = vpc_flow_logs_config.VpcFlowLogsConfig.to_json( + vpc_flow_logs_config.VpcFlowLogsConfig() + ) + req.return_value.content = return_value + + request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() + post_with_metadata.return_value = ( + vpc_flow_logs_config.VpcFlowLogsConfig(), + metadata, + ) + + client.get_vpc_flow_logs_config( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_create_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.create_vpc_flow_logs_config(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + dict, + ], +) +def test_create_vpc_flow_logs_config_rest_call_success(request_type): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["vpc_flow_logs_config"] = { + "name": "name_value", + "description": "description_value", + "state": 1, + "aggregation_interval": 1, + "flow_sampling": 0.1394, + "metadata": 1, + "metadata_fields": ["metadata_fields_value1", "metadata_fields_value2"], + "filter_expr": "filter_expr_value", + "cross_project_metadata": 1, + "target_resource_state": 1, + "network": "network_value", + "subnet": "subnet_value", + "interconnect_attachment": "interconnect_attachment_value", + "vpn_tunnel": "vpn_tunnel_value", + "labels": {}, + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.meta.fields[ + "vpc_flow_logs_config" + ] + + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + + if is_field_type_proto_plus_type: + message_fields = field.message.meta.fields.values() + # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types + else: # pragma: NO COVER + message_fields = field.message.DESCRIPTOR.fields + return message_fields + + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] + + subfields_not_in_runtime = [] + + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init[ + "vpc_flow_logs_config" + ].items(): # pragma: NO COVER + result = None + is_repeated = False + # For repeated fields + if isinstance(value, list) and len(value): + is_repeated = True + result = value[0] + # For fields where the type is another message + if isinstance(value, dict): + result = value + + if result and hasattr(result, "keys"): + for subfield in result.keys(): + if (field, subfield) not in runtime_nested_fields: + subfields_not_in_runtime.append( + { + "field": field, + "subfield": subfield, + "is_repeated": is_repeated, + } + ) + + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["vpc_flow_logs_config"][field])): + del request_init["vpc_flow_logs_config"][field][i][subfield] + else: + del request_init["vpc_flow_logs_config"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = vpc_flow_logs_config.VpcFlowLogsConfig( - name="name_value", - description="description_value", - state=vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED, - aggregation_interval=vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC, - flow_sampling=0.1394, - metadata=vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA, - metadata_fields=["metadata_fields_value"], - filter_expr="filter_expr_value", - target_resource_state=vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS, - interconnect_attachment="interconnect_attachment_value", - ) + return_value = operations_pb2.Operation(name="operations/spam") # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = vpc_flow_logs_config.VpcFlowLogsConfig.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.get_vpc_flow_logs_config(request) + response = client.create_vpc_flow_logs_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, vpc_flow_logs_config.VpcFlowLogsConfig) - assert response.name == "name_value" - assert response.description == "description_value" - assert response.state == vpc_flow_logs_config.VpcFlowLogsConfig.State.ENABLED - assert ( - response.aggregation_interval - == vpc_flow_logs_config.VpcFlowLogsConfig.AggregationInterval.INTERVAL_5_SEC - ) - assert math.isclose(response.flow_sampling, 0.1394, rel_tol=1e-6) - assert ( - response.metadata - == vpc_flow_logs_config.VpcFlowLogsConfig.Metadata.INCLUDE_ALL_METADATA - ) - assert response.metadata_fields == ["metadata_fields_value"] - assert response.filter_expr == "filter_expr_value" - assert ( - response.target_resource_state - == vpc_flow_logs_config.VpcFlowLogsConfig.TargetResourceState.TARGET_RESOURCE_EXISTS - ) + json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_vpc_flow_logs_config_rest_interceptors(null_interceptor): +def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -4900,18 +6638,20 @@ def test_get_vpc_flow_logs_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "post_get_vpc_flow_logs_config" + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.VpcFlowLogsServiceRestInterceptor, "post_create_vpc_flow_logs_config" ) as post, mock.patch.object( transports.VpcFlowLogsServiceRestInterceptor, - "post_get_vpc_flow_logs_config_with_metadata", + "post_create_vpc_flow_logs_config_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "pre_get_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, "pre_create_vpc_flow_logs_config" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = vpc_flow_logs.GetVpcFlowLogsConfigRequest.pb( - vpc_flow_logs.GetVpcFlowLogsConfigRequest() + pb_message = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.CreateVpcFlowLogsConfigRequest() ) transcode.return_value = { "method": "post", @@ -4923,24 +6663,19 @@ def test_get_vpc_flow_logs_config_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = vpc_flow_logs_config.VpcFlowLogsConfig.to_json( - vpc_flow_logs_config.VpcFlowLogsConfig() - ) + return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = vpc_flow_logs.GetVpcFlowLogsConfigRequest() + request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = vpc_flow_logs_config.VpcFlowLogsConfig() - post_with_metadata.return_value = ( - vpc_flow_logs_config.VpcFlowLogsConfig(), - metadata, - ) + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.get_vpc_flow_logs_config( + client.create_vpc_flow_logs_config( request, metadata=[ ("key", "val"), @@ -4953,14 +6688,18 @@ def test_get_vpc_flow_logs_config_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_vpc_flow_logs_config_rest_bad_request( - request_type=vpc_flow_logs.CreateVpcFlowLogsConfigRequest, +def test_update_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, ): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "vpc_flow_logs_config": { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -4975,25 +6714,29 @@ def test_create_vpc_flow_logs_config_rest_bad_request( response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.create_vpc_flow_logs_config(request) + client.update_vpc_flow_logs_config(request) @pytest.mark.parametrize( "request_type", [ - vpc_flow_logs.CreateVpcFlowLogsConfigRequest, + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, dict, ], ) -def test_create_vpc_flow_logs_config_rest_call_success(request_type): +def test_update_vpc_flow_logs_config_rest_call_success(request_type): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "vpc_flow_logs_config": { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } + } request_init["vpc_flow_logs_config"] = { - "name": "name_value", + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3", "description": "description_value", "state": 1, "aggregation_interval": 1, @@ -5001,7 +6744,10 @@ def test_create_vpc_flow_logs_config_rest_call_success(request_type): "metadata": 1, "metadata_fields": ["metadata_fields_value1", "metadata_fields_value2"], "filter_expr": "filter_expr_value", + "cross_project_metadata": 1, "target_resource_state": 1, + "network": "network_value", + "subnet": "subnet_value", "interconnect_attachment": "interconnect_attachment_value", "vpn_tunnel": "vpn_tunnel_value", "labels": {}, @@ -5013,7 +6759,7 @@ def test_create_vpc_flow_logs_config_rest_call_success(request_type): # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.meta.fields[ + test_field = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.meta.fields[ "vpc_flow_logs_config" ] @@ -5067,18 +6813,146 @@ def get_message_fields(field): } ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["vpc_flow_logs_config"][field])): - del request_init["vpc_flow_logs_config"][field][i][subfield] - else: - del request_init["vpc_flow_logs_config"][field][subfield] + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["vpc_flow_logs_config"][field])): + del request_init["vpc_flow_logs_config"][field][i][subfield] + else: + del request_init["vpc_flow_logs_config"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.update_vpc_flow_logs_config(request) + + # Establish that the response is the type that we expect. + json_return_value = json_format.MessageToJson(return_value) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_vpc_flow_logs_config_rest_interceptors(null_interceptor): + transport = transports.VpcFlowLogsServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.VpcFlowLogsServiceRestInterceptor(), + ) + client = VpcFlowLogsServiceClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.VpcFlowLogsServiceRestInterceptor, "post_update_vpc_flow_logs_config" + ) as post, mock.patch.object( + transports.VpcFlowLogsServiceRestInterceptor, + "post_update_vpc_flow_logs_config_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.VpcFlowLogsServiceRestInterceptor, "pre_update_vpc_flow_logs_config" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value + + request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata + + client.update_vpc_flow_logs_config( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_delete_vpc_flow_logs_config_rest_bad_request( + request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, +): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/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 = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.delete_vpc_flow_logs_config(request) + + +@pytest.mark.parametrize( + "request_type", + [ + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + dict, + ], +) +def test_delete_vpc_flow_logs_config_rest_call_success(request_type): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -5093,14 +6967,14 @@ def get_message_fields(field): response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.create_vpc_flow_logs_config(request) + response = client.delete_vpc_flow_logs_config(request) # Establish that the response is the type that we expect. json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): +def test_delete_vpc_flow_logs_config_rest_interceptors(null_interceptor): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -5116,18 +6990,18 @@ def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): ) as transcode, mock.patch.object( operation.Operation, "_set_result_from_operation" ), mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "post_create_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, "post_delete_vpc_flow_logs_config" ) as post, mock.patch.object( transports.VpcFlowLogsServiceRestInterceptor, - "post_create_vpc_flow_logs_config_with_metadata", + "post_delete_vpc_flow_logs_config_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "pre_create_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, "pre_delete_vpc_flow_logs_config" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = vpc_flow_logs.CreateVpcFlowLogsConfigRequest.pb( - vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + pb_message = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest.pb( + vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() ) transcode.return_value = { "method": "post", @@ -5142,7 +7016,7 @@ def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = vpc_flow_logs.CreateVpcFlowLogsConfigRequest() + request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -5151,7 +7025,7 @@ def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): post.return_value = operations_pb2.Operation() post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.create_vpc_flow_logs_config( + client.delete_vpc_flow_logs_config( request, metadata=[ ("key", "val"), @@ -5164,18 +7038,14 @@ def test_create_vpc_flow_logs_config_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_vpc_flow_logs_config_rest_bad_request( - request_type=vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, +def test_query_org_vpc_flow_logs_configs_rest_bad_request( + request_type=vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, ): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "vpc_flow_logs_config": { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } - } + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -5190,136 +7060,53 @@ def test_update_vpc_flow_logs_config_rest_bad_request( response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.update_vpc_flow_logs_config(request) + client.query_org_vpc_flow_logs_configs(request) @pytest.mark.parametrize( "request_type", [ - vpc_flow_logs.UpdateVpcFlowLogsConfigRequest, + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest, dict, ], ) -def test_update_vpc_flow_logs_config_rest_call_success(request_type): +def test_query_org_vpc_flow_logs_configs_rest_call_success(request_type): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "vpc_flow_logs_config": { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } - } - request_init["vpc_flow_logs_config"] = { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3", - "description": "description_value", - "state": 1, - "aggregation_interval": 1, - "flow_sampling": 0.1394, - "metadata": 1, - "metadata_fields": ["metadata_fields_value1", "metadata_fields_value2"], - "filter_expr": "filter_expr_value", - "target_resource_state": 1, - "interconnect_attachment": "interconnect_attachment_value", - "vpn_tunnel": "vpn_tunnel_value", - "labels": {}, - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.meta.fields[ - "vpc_flow_logs_config" - ] - - def get_message_fields(field): - # Given a field which is a message (composite type), return a list with - # all the fields of the message. - # If the field is not a composite type, return an empty list. - message_fields = [] - - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") - - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields - - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] - - subfields_not_in_runtime = [] - - # For each item in the sample request, create a list of sub fields which are not present at runtime - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init[ - "vpc_flow_logs_config" - ].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value - - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) - - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["vpc_flow_logs_config"][field])): - del request_init["vpc_flow_logs_config"][field][i][subfield] - else: - del request_init["vpc_flow_logs_config"][field][subfield] + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.update_vpc_flow_logs_config(request) + response = client.query_org_vpc_flow_logs_configs(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert isinstance(response, pagers.QueryOrgVpcFlowLogsConfigsPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_vpc_flow_logs_config_rest_interceptors(null_interceptor): +def test_query_org_vpc_flow_logs_configs_rest_interceptors(null_interceptor): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -5333,20 +7120,20 @@ def test_update_vpc_flow_logs_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "post_update_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, + "post_query_org_vpc_flow_logs_configs", ) as post, mock.patch.object( transports.VpcFlowLogsServiceRestInterceptor, - "post_update_vpc_flow_logs_config_with_metadata", + "post_query_org_vpc_flow_logs_configs_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "pre_update_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, + "pre_query_org_vpc_flow_logs_configs", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest.pb( - vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + pb_message = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest.pb( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() ) transcode.return_value = { "method": "post", @@ -5358,19 +7145,24 @@ def test_update_vpc_flow_logs_config_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) + return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse.to_json( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() + ) req.return_value.content = return_value - request = vpc_flow_logs.UpdateVpcFlowLogsConfigRequest() + request = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata + post.return_value = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse() + post_with_metadata.return_value = ( + vpc_flow_logs.QueryOrgVpcFlowLogsConfigsResponse(), + metadata, + ) - client.update_vpc_flow_logs_config( + client.query_org_vpc_flow_logs_configs( request, metadata=[ ("key", "val"), @@ -5383,16 +7175,14 @@ def test_update_vpc_flow_logs_config_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_vpc_flow_logs_config_rest_bad_request( - request_type=vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, +def test_show_effective_flow_logs_configs_rest_bad_request( + request_type=vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, ): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -5407,47 +7197,55 @@ def test_delete_vpc_flow_logs_config_rest_bad_request( response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_vpc_flow_logs_config(request) + client.show_effective_flow_logs_configs(request) @pytest.mark.parametrize( "request_type", [ - vpc_flow_logs.DeleteVpcFlowLogsConfigRequest, + vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest, dict, ], ) -def test_delete_vpc_flow_logs_config_rest_call_success(request_type): +def test_show_effective_flow_logs_configs_rest_call_success(request_type): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/vpcFlowLogsConfigs/sample3" - } + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.pb( + return_value + ) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_vpc_flow_logs_config(request) + response = client.show_effective_flow_logs_configs(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert isinstance(response, pagers.ShowEffectiveFlowLogsConfigsPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_vpc_flow_logs_config_rest_interceptors(null_interceptor): +def test_show_effective_flow_logs_configs_rest_interceptors(null_interceptor): transport = transports.VpcFlowLogsServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -5461,20 +7259,20 @@ def test_delete_vpc_flow_logs_config_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "post_delete_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, + "post_show_effective_flow_logs_configs", ) as post, mock.patch.object( transports.VpcFlowLogsServiceRestInterceptor, - "post_delete_vpc_flow_logs_config_with_metadata", + "post_show_effective_flow_logs_configs_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.VpcFlowLogsServiceRestInterceptor, "pre_delete_vpc_flow_logs_config" + transports.VpcFlowLogsServiceRestInterceptor, + "pre_show_effective_flow_logs_configs", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest.pb( - vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + pb_message = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest.pb( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() ) transcode.return_value = { "method": "post", @@ -5486,19 +7284,24 @@ def test_delete_vpc_flow_logs_config_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) + return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse.to_json( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() + ) req.return_value.content = return_value - request = vpc_flow_logs.DeleteVpcFlowLogsConfigRequest() + request = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata + post.return_value = vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse() + post_with_metadata.return_value = ( + vpc_flow_logs.ShowEffectiveFlowLogsConfigsResponse(), + metadata, + ) - client.delete_vpc_flow_logs_config( + client.show_effective_flow_logs_configs( request, metadata=[ ("key", "val"), @@ -6191,6 +7994,50 @@ def test_delete_vpc_flow_logs_config_empty_call_rest(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_query_org_vpc_flow_logs_configs_empty_call_rest(): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.query_org_vpc_flow_logs_configs), "__call__" + ) as call: + client.query_org_vpc_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.QueryOrgVpcFlowLogsConfigsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_show_effective_flow_logs_configs_empty_call_rest(): + client = VpcFlowLogsServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.show_effective_flow_logs_configs), "__call__" + ) as call: + client.show_effective_flow_logs_configs(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = vpc_flow_logs.ShowEffectiveFlowLogsConfigsRequest() + + assert args[0] == request_msg + + def test_vpc_flow_logs_service_rest_lro_client(): client = VpcFlowLogsServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -6246,6 +8093,8 @@ def test_vpc_flow_logs_service_base_transport(): "create_vpc_flow_logs_config", "update_vpc_flow_logs_config", "delete_vpc_flow_logs_config", + "query_org_vpc_flow_logs_configs", + "show_effective_flow_logs_configs", "set_iam_policy", "get_iam_policy", "test_iam_permissions", @@ -6535,6 +8384,12 @@ def test_vpc_flow_logs_service_client_transport_session_collision(transport_name session1 = client1.transport.delete_vpc_flow_logs_config._session session2 = client2.transport.delete_vpc_flow_logs_config._session assert session1 != session2 + session1 = client1.transport.query_org_vpc_flow_logs_configs._session + session2 = client2.transport.query_org_vpc_flow_logs_configs._session + assert session1 != session2 + session1 = client1.transport.show_effective_flow_logs_configs._session + session2 = client2.transport.show_effective_flow_logs_configs._session + assert session1 != session2 def test_vpc_flow_logs_service_grpc_transport_channel():