diff --git a/packages/google-analytics-admin/google/analytics/admin/__init__.py b/packages/google-analytics-admin/google/analytics/admin/__init__.py index a03c1f44377c..9ab3e3e34220 100644 --- a/packages/google-analytics-admin/google/analytics/admin/__init__.py +++ b/packages/google-analytics-admin/google/analytics/admin/__init__.py @@ -83,6 +83,7 @@ CreateKeyEventRequest, CreateMeasurementProtocolSecretRequest, CreatePropertyRequest, + CreateReportingDataAnnotationRequest, CreateRollupPropertyRequest, CreateRollupPropertyResponse, CreateRollupPropertySourceLinkRequest, @@ -108,6 +109,7 @@ DeleteKeyEventRequest, DeleteMeasurementProtocolSecretRequest, DeletePropertyRequest, + DeleteReportingDataAnnotationRequest, DeleteRollupPropertySourceLinkRequest, DeleteSearchAds360LinkRequest, DeleteSKAdNetworkConversionValueSchemaRequest, @@ -142,6 +144,7 @@ GetKeyEventRequest, GetMeasurementProtocolSecretRequest, GetPropertyRequest, + GetReportingDataAnnotationRequest, GetRollupPropertySourceLinkRequest, GetSearchAds360LinkRequest, GetSKAdNetworkConversionValueSchemaRequest, @@ -192,6 +195,8 @@ ListMeasurementProtocolSecretsResponse, ListPropertiesRequest, ListPropertiesResponse, + ListReportingDataAnnotationsRequest, + ListReportingDataAnnotationsResponse, ListRollupPropertySourceLinksRequest, ListRollupPropertySourceLinksResponse, ListSearchAds360LinksRequest, @@ -211,6 +216,8 @@ SearchChangeHistoryEventsResponse, SetAutomatedGa4ConfigurationOptOutRequest, SetAutomatedGa4ConfigurationOptOutResponse, + SubmitUserDeletionRequest, + SubmitUserDeletionResponse, UpdateAccessBindingRequest, UpdateAccountRequest, UpdateAttributionSettingsRequest, @@ -234,6 +241,7 @@ UpdateKeyEventRequest, UpdateMeasurementProtocolSecretRequest, UpdatePropertyRequest, + UpdateReportingDataAnnotationRequest, UpdateSearchAds360LinkRequest, UpdateSKAdNetworkConversionValueSchemaRequest, UpdateSubpropertyEventFilterRequest, @@ -312,6 +320,7 @@ Property, PropertySummary, PropertyType, + ReportingDataAnnotation, RollupPropertySourceLink, SearchAds360Link, ServiceLevel, @@ -384,6 +393,7 @@ "CreateKeyEventRequest", "CreateMeasurementProtocolSecretRequest", "CreatePropertyRequest", + "CreateReportingDataAnnotationRequest", "CreateRollupPropertyRequest", "CreateRollupPropertyResponse", "CreateRollupPropertySourceLinkRequest", @@ -409,6 +419,7 @@ "DeleteKeyEventRequest", "DeleteMeasurementProtocolSecretRequest", "DeletePropertyRequest", + "DeleteReportingDataAnnotationRequest", "DeleteRollupPropertySourceLinkRequest", "DeleteSearchAds360LinkRequest", "DeleteSKAdNetworkConversionValueSchemaRequest", @@ -443,6 +454,7 @@ "GetKeyEventRequest", "GetMeasurementProtocolSecretRequest", "GetPropertyRequest", + "GetReportingDataAnnotationRequest", "GetRollupPropertySourceLinkRequest", "GetSearchAds360LinkRequest", "GetSKAdNetworkConversionValueSchemaRequest", @@ -493,6 +505,8 @@ "ListMeasurementProtocolSecretsResponse", "ListPropertiesRequest", "ListPropertiesResponse", + "ListReportingDataAnnotationsRequest", + "ListReportingDataAnnotationsResponse", "ListRollupPropertySourceLinksRequest", "ListRollupPropertySourceLinksResponse", "ListSearchAds360LinksRequest", @@ -512,6 +526,8 @@ "SearchChangeHistoryEventsResponse", "SetAutomatedGa4ConfigurationOptOutRequest", "SetAutomatedGa4ConfigurationOptOutResponse", + "SubmitUserDeletionRequest", + "SubmitUserDeletionResponse", "UpdateAccessBindingRequest", "UpdateAccountRequest", "UpdateAttributionSettingsRequest", @@ -535,6 +551,7 @@ "UpdateKeyEventRequest", "UpdateMeasurementProtocolSecretRequest", "UpdatePropertyRequest", + "UpdateReportingDataAnnotationRequest", "UpdateSearchAds360LinkRequest", "UpdateSKAdNetworkConversionValueSchemaRequest", "UpdateSubpropertyEventFilterRequest", @@ -593,6 +610,7 @@ "PostbackWindow", "Property", "PropertySummary", + "ReportingDataAnnotation", "RollupPropertySourceLink", "SearchAds360Link", "SKAdNetworkConversionValueSchema", diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/__init__.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/__init__.py index 7e6ed0c296cb..f9c903f0e6a6 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/__init__.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/__init__.py @@ -81,6 +81,7 @@ CreateKeyEventRequest, CreateMeasurementProtocolSecretRequest, CreatePropertyRequest, + CreateReportingDataAnnotationRequest, CreateRollupPropertyRequest, CreateRollupPropertyResponse, CreateRollupPropertySourceLinkRequest, @@ -106,6 +107,7 @@ DeleteKeyEventRequest, DeleteMeasurementProtocolSecretRequest, DeletePropertyRequest, + DeleteReportingDataAnnotationRequest, DeleteRollupPropertySourceLinkRequest, DeleteSearchAds360LinkRequest, DeleteSKAdNetworkConversionValueSchemaRequest, @@ -140,6 +142,7 @@ GetKeyEventRequest, GetMeasurementProtocolSecretRequest, GetPropertyRequest, + GetReportingDataAnnotationRequest, GetRollupPropertySourceLinkRequest, GetSearchAds360LinkRequest, GetSKAdNetworkConversionValueSchemaRequest, @@ -190,6 +193,8 @@ ListMeasurementProtocolSecretsResponse, ListPropertiesRequest, ListPropertiesResponse, + ListReportingDataAnnotationsRequest, + ListReportingDataAnnotationsResponse, ListRollupPropertySourceLinksRequest, ListRollupPropertySourceLinksResponse, ListSearchAds360LinksRequest, @@ -209,6 +214,8 @@ SearchChangeHistoryEventsResponse, SetAutomatedGa4ConfigurationOptOutRequest, SetAutomatedGa4ConfigurationOptOutResponse, + SubmitUserDeletionRequest, + SubmitUserDeletionResponse, UpdateAccessBindingRequest, UpdateAccountRequest, UpdateAttributionSettingsRequest, @@ -232,6 +239,7 @@ UpdateKeyEventRequest, UpdateMeasurementProtocolSecretRequest, UpdatePropertyRequest, + UpdateReportingDataAnnotationRequest, UpdateSearchAds360LinkRequest, UpdateSKAdNetworkConversionValueSchemaRequest, UpdateSubpropertyEventFilterRequest, @@ -310,6 +318,7 @@ Property, PropertySummary, PropertyType, + ReportingDataAnnotation, RollupPropertySourceLink, SearchAds360Link, ServiceLevel, @@ -411,6 +420,7 @@ "CreateKeyEventRequest", "CreateMeasurementProtocolSecretRequest", "CreatePropertyRequest", + "CreateReportingDataAnnotationRequest", "CreateRollupPropertyRequest", "CreateRollupPropertyResponse", "CreateRollupPropertySourceLinkRequest", @@ -442,6 +452,7 @@ "DeleteKeyEventRequest", "DeleteMeasurementProtocolSecretRequest", "DeletePropertyRequest", + "DeleteReportingDataAnnotationRequest", "DeleteRollupPropertySourceLinkRequest", "DeleteSKAdNetworkConversionValueSchemaRequest", "DeleteSearchAds360LinkRequest", @@ -487,6 +498,7 @@ "GetKeyEventRequest", "GetMeasurementProtocolSecretRequest", "GetPropertyRequest", + "GetReportingDataAnnotationRequest", "GetRollupPropertySourceLinkRequest", "GetSKAdNetworkConversionValueSchemaRequest", "GetSearchAds360LinkRequest", @@ -548,6 +560,8 @@ "ListMeasurementProtocolSecretsResponse", "ListPropertiesRequest", "ListPropertiesResponse", + "ListReportingDataAnnotationsRequest", + "ListReportingDataAnnotationsResponse", "ListRollupPropertySourceLinksRequest", "ListRollupPropertySourceLinksResponse", "ListSKAdNetworkConversionValueSchemasRequest", @@ -569,6 +583,7 @@ "ProvisionSubpropertyRequest", "ProvisionSubpropertyResponse", "ReorderEventEditRulesRequest", + "ReportingDataAnnotation", "RollupPropertySourceLink", "RunAccessReportRequest", "RunAccessReportResponse", @@ -579,6 +594,8 @@ "ServiceLevel", "SetAutomatedGa4ConfigurationOptOutRequest", "SetAutomatedGa4ConfigurationOptOutResponse", + "SubmitUserDeletionRequest", + "SubmitUserDeletionResponse", "SubpropertyEventFilter", "SubpropertyEventFilterClause", "SubpropertyEventFilterCondition", @@ -607,6 +624,7 @@ "UpdateKeyEventRequest", "UpdateMeasurementProtocolSecretRequest", "UpdatePropertyRequest", + "UpdateReportingDataAnnotationRequest", "UpdateSKAdNetworkConversionValueSchemaRequest", "UpdateSearchAds360LinkRequest", "UpdateSubpropertyEventFilterRequest", diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/gapic_metadata.json b/packages/google-analytics-admin/google/analytics/admin_v1alpha/gapic_metadata.json index d379bf7a5952..e6f29911ac8d 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/gapic_metadata.json +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/gapic_metadata.json @@ -165,6 +165,11 @@ "create_property" ] }, + "CreateReportingDataAnnotation": { + "methods": [ + "create_reporting_data_annotation" + ] + }, "CreateRollupProperty": { "methods": [ "create_rollup_property" @@ -285,6 +290,11 @@ "delete_property" ] }, + "DeleteReportingDataAnnotation": { + "methods": [ + "delete_reporting_data_annotation" + ] + }, "DeleteRollupPropertySourceLink": { "methods": [ "delete_rollup_property_source_link" @@ -445,6 +455,11 @@ "get_property" ] }, + "GetReportingDataAnnotation": { + "methods": [ + "get_reporting_data_annotation" + ] + }, "GetRollupPropertySourceLink": { "methods": [ "get_rollup_property_source_link" @@ -580,6 +595,11 @@ "list_properties" ] }, + "ListReportingDataAnnotations": { + "methods": [ + "list_reporting_data_annotations" + ] + }, "ListRollupPropertySourceLinks": { "methods": [ "list_rollup_property_source_links" @@ -630,6 +650,11 @@ "set_automated_ga4_configuration_opt_out" ] }, + "SubmitUserDeletion": { + "methods": [ + "submit_user_deletion" + ] + }, "UpdateAccessBinding": { "methods": [ "update_access_binding" @@ -745,6 +770,11 @@ "update_property" ] }, + "UpdateReportingDataAnnotation": { + "methods": [ + "update_reporting_data_annotation" + ] + }, "UpdateSKAdNetworkConversionValueSchema": { "methods": [ "update_sk_ad_network_conversion_value_schema" @@ -920,6 +950,11 @@ "create_property" ] }, + "CreateReportingDataAnnotation": { + "methods": [ + "create_reporting_data_annotation" + ] + }, "CreateRollupProperty": { "methods": [ "create_rollup_property" @@ -1040,6 +1075,11 @@ "delete_property" ] }, + "DeleteReportingDataAnnotation": { + "methods": [ + "delete_reporting_data_annotation" + ] + }, "DeleteRollupPropertySourceLink": { "methods": [ "delete_rollup_property_source_link" @@ -1200,6 +1240,11 @@ "get_property" ] }, + "GetReportingDataAnnotation": { + "methods": [ + "get_reporting_data_annotation" + ] + }, "GetRollupPropertySourceLink": { "methods": [ "get_rollup_property_source_link" @@ -1335,6 +1380,11 @@ "list_properties" ] }, + "ListReportingDataAnnotations": { + "methods": [ + "list_reporting_data_annotations" + ] + }, "ListRollupPropertySourceLinks": { "methods": [ "list_rollup_property_source_links" @@ -1385,6 +1435,11 @@ "set_automated_ga4_configuration_opt_out" ] }, + "SubmitUserDeletion": { + "methods": [ + "submit_user_deletion" + ] + }, "UpdateAccessBinding": { "methods": [ "update_access_binding" @@ -1500,6 +1555,11 @@ "update_property" ] }, + "UpdateReportingDataAnnotation": { + "methods": [ + "update_reporting_data_annotation" + ] + }, "UpdateSKAdNetworkConversionValueSchema": { "methods": [ "update_sk_ad_network_conversion_value_schema" @@ -1675,6 +1735,11 @@ "create_property" ] }, + "CreateReportingDataAnnotation": { + "methods": [ + "create_reporting_data_annotation" + ] + }, "CreateRollupProperty": { "methods": [ "create_rollup_property" @@ -1795,6 +1860,11 @@ "delete_property" ] }, + "DeleteReportingDataAnnotation": { + "methods": [ + "delete_reporting_data_annotation" + ] + }, "DeleteRollupPropertySourceLink": { "methods": [ "delete_rollup_property_source_link" @@ -1955,6 +2025,11 @@ "get_property" ] }, + "GetReportingDataAnnotation": { + "methods": [ + "get_reporting_data_annotation" + ] + }, "GetRollupPropertySourceLink": { "methods": [ "get_rollup_property_source_link" @@ -2090,6 +2165,11 @@ "list_properties" ] }, + "ListReportingDataAnnotations": { + "methods": [ + "list_reporting_data_annotations" + ] + }, "ListRollupPropertySourceLinks": { "methods": [ "list_rollup_property_source_links" @@ -2140,6 +2220,11 @@ "set_automated_ga4_configuration_opt_out" ] }, + "SubmitUserDeletion": { + "methods": [ + "submit_user_deletion" + ] + }, "UpdateAccessBinding": { "methods": [ "update_access_binding" @@ -2255,6 +2340,11 @@ "update_property" ] }, + "UpdateReportingDataAnnotation": { + "methods": [ + "update_reporting_data_annotation" + ] + }, "UpdateSKAdNetworkConversionValueSchema": { "methods": [ "update_sk_ad_network_conversion_value_schema" diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/async_client.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/async_client.py index 8ec3bd8b6f40..98dcae4be650 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/async_client.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/async_client.py @@ -47,6 +47,7 @@ from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from google.protobuf import wrappers_pb2 # type: ignore +from google.type import date_pb2 # type: ignore from google.analytics.admin_v1alpha.services.analytics_admin_service import pagers from google.analytics.admin_v1alpha.types import channel_group as gaa_channel_group @@ -241,6 +242,12 @@ class AnalyticsAdminServiceAsyncClient: ) property_path = staticmethod(AnalyticsAdminServiceClient.property_path) parse_property_path = staticmethod(AnalyticsAdminServiceClient.parse_property_path) + reporting_data_annotation_path = staticmethod( + AnalyticsAdminServiceClient.reporting_data_annotation_path + ) + parse_reporting_data_annotation_path = staticmethod( + AnalyticsAdminServiceClient.parse_reporting_data_annotation_path + ) rollup_property_source_link_path = staticmethod( AnalyticsAdminServiceClient.rollup_property_source_link_path ) @@ -14107,6 +14114,577 @@ async def delete_subproperty_event_filter( metadata=metadata, ) + async def create_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.CreateReportingDataAnnotationRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + reporting_data_annotation: Optional[resources.ReportingDataAnnotation] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Creates a Reporting Data Annotation. + + Args: + request (Optional[Union[google.analytics.admin_v1alpha.types.CreateReportingDataAnnotationRequest, dict]]): + The request object. Request message for + CreateReportingDataAnnotation RPC. + parent (:class:`str`): + Required. The property for which to create a Reporting + Data Annotation. Format: properties/property_id Example: + properties/123 + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + reporting_data_annotation (:class:`google.analytics.admin_v1alpha.types.ReportingDataAnnotation`): + Required. The Reporting Data + Annotation to create. + + This corresponds to the ``reporting_data_annotation`` 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.analytics.admin_v1alpha.types.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + # 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, reporting_data_annotation] + 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, analytics_admin.CreateReportingDataAnnotationRequest + ): + request = analytics_admin.CreateReportingDataAnnotationRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if reporting_data_annotation is not None: + request.reporting_data_annotation = reporting_data_annotation + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.create_reporting_data_annotation + ] + + # 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, + ) + + # Done; return the response. + return response + + async def get_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.GetReportingDataAnnotationRequest, 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]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Lookup a single Reporting Data Annotation. + + Args: + request (Optional[Union[google.analytics.admin_v1alpha.types.GetReportingDataAnnotationRequest, dict]]): + The request object. Request message for + GetReportingDataAnnotation RPC. + name (:class:`str`): + Required. Resource name of the Reporting Data Annotation + to lookup. Format: + properties/property_id/reportingDataAnnotations/reportingDataAnnotation + Example: properties/123/reportingDataAnnotations/456 + + 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.analytics.admin_v1alpha.types.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + # 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, analytics_admin.GetReportingDataAnnotationRequest): + request = analytics_admin.GetReportingDataAnnotationRequest(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_reporting_data_annotation + ] + + # 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_reporting_data_annotations( + self, + request: Optional[ + Union[analytics_admin.ListReportingDataAnnotationsRequest, 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.ListReportingDataAnnotationsAsyncPager: + r"""List all Reporting Data Annotations on a property. + + Args: + request (Optional[Union[google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsRequest, dict]]): + The request object. Request message for + ListReportingDataAnnotation RPC. + parent (:class:`str`): + Required. Resource name of the property. Format: + properties/property_id Example: properties/123 + + 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.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListReportingDataAnnotationsAsyncPager: + Response message for + ListReportingDataAnnotation RPC. + 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, analytics_admin.ListReportingDataAnnotationsRequest): + request = analytics_admin.ListReportingDataAnnotationsRequest(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_reporting_data_annotations + ] + + # 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.ListReportingDataAnnotationsAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def update_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.UpdateReportingDataAnnotationRequest, dict] + ] = None, + *, + reporting_data_annotation: Optional[resources.ReportingDataAnnotation] = 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]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Updates a Reporting Data Annotation. + + Args: + request (Optional[Union[google.analytics.admin_v1alpha.types.UpdateReportingDataAnnotationRequest, dict]]): + The request object. Request message for + UpdateReportingDataAnnotation RPC. + reporting_data_annotation (:class:`google.analytics.admin_v1alpha.types.ReportingDataAnnotation`): + Required. The Reporting Data + Annotation to update. + + This corresponds to the ``reporting_data_annotation`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Optional. The list of fields to update. Field names must + be in snake case (for example, "field_to_update"). + Omitted fields will not be updated. To replace the + entire entity, use one path with the string "*" to match + all fields. + + 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.analytics.admin_v1alpha.types.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + # 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 = [reporting_data_annotation, 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, analytics_admin.UpdateReportingDataAnnotationRequest + ): + request = analytics_admin.UpdateReportingDataAnnotationRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if reporting_data_annotation is not None: + request.reporting_data_annotation = reporting_data_annotation + 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_reporting_data_annotation + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ( + "reporting_data_annotation.name", + request.reporting_data_annotation.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_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.DeleteReportingDataAnnotationRequest, 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]]] = (), + ) -> None: + r"""Deletes a Reporting Data Annotation. + + Args: + request (Optional[Union[google.analytics.admin_v1alpha.types.DeleteReportingDataAnnotationRequest, dict]]): + The request object. Request message for + DeleteReportingDataAnnotation RPC. + name (:class:`str`): + Required. Resource name of the Reporting Data Annotation + to delete. Format: + properties/property_id/reportingDataAnnotations/reporting_data_annotation + Example: properties/123/reportingDataAnnotations/456 + + 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`. + """ + # 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, analytics_admin.DeleteReportingDataAnnotationRequest + ): + request = analytics_admin.DeleteReportingDataAnnotationRequest(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_reporting_data_annotation + ] + + # 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 submit_user_deletion( + self, + request: Optional[ + Union[analytics_admin.SubmitUserDeletionRequest, 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]]] = (), + ) -> analytics_admin.SubmitUserDeletionResponse: + r"""Submits a request for user deletion for a property. + + Args: + request (Optional[Union[google.analytics.admin_v1alpha.types.SubmitUserDeletionRequest, dict]]): + The request object. Request message for + SubmitUserDeletion RPC. + name (:class:`str`): + Required. The name of the property to + submit user deletion for. + + 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.analytics.admin_v1alpha.types.SubmitUserDeletionResponse: + Response message for + SubmitUserDeletion 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 = [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, analytics_admin.SubmitUserDeletionRequest): + request = analytics_admin.SubmitUserDeletionRequest(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.submit_user_deletion + ] + + # 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) -> "AnalyticsAdminServiceAsyncClient": return self diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/client.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/client.py index 73fb14640ee9..c1442990ead1 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/client.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/client.py @@ -63,6 +63,7 @@ from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from google.protobuf import wrappers_pb2 # type: ignore +from google.type import date_pb2 # type: ignore from google.analytics.admin_v1alpha.services.analytics_admin_service import pagers from google.analytics.admin_v1alpha.types import channel_group as gaa_channel_group @@ -772,6 +773,26 @@ def parse_property_path(path: str) -> Dict[str, str]: m = re.match(r"^properties/(?P.+?)$", path) return m.groupdict() if m else {} + @staticmethod + def reporting_data_annotation_path( + property: str, + reporting_data_annotation: str, + ) -> str: + """Returns a fully-qualified reporting_data_annotation string.""" + return "properties/{property}/reportingDataAnnotations/{reporting_data_annotation}".format( + property=property, + reporting_data_annotation=reporting_data_annotation, + ) + + @staticmethod + def parse_reporting_data_annotation_path(path: str) -> Dict[str, str]: + """Parses a reporting_data_annotation path into its component segments.""" + m = re.match( + r"^properties/(?P.+?)/reportingDataAnnotations/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + @staticmethod def rollup_property_source_link_path( property: str, @@ -14658,6 +14679,569 @@ def delete_subproperty_event_filter( metadata=metadata, ) + def create_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.CreateReportingDataAnnotationRequest, dict] + ] = None, + *, + parent: Optional[str] = None, + reporting_data_annotation: Optional[resources.ReportingDataAnnotation] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Creates a Reporting Data Annotation. + + Args: + request (Union[google.analytics.admin_v1alpha.types.CreateReportingDataAnnotationRequest, dict]): + The request object. Request message for + CreateReportingDataAnnotation RPC. + parent (str): + Required. The property for which to create a Reporting + Data Annotation. Format: properties/property_id Example: + properties/123 + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + reporting_data_annotation (google.analytics.admin_v1alpha.types.ReportingDataAnnotation): + Required. The Reporting Data + Annotation to create. + + This corresponds to the ``reporting_data_annotation`` 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.analytics.admin_v1alpha.types.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + # 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, reporting_data_annotation] + 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, analytics_admin.CreateReportingDataAnnotationRequest + ): + request = analytics_admin.CreateReportingDataAnnotationRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if reporting_data_annotation is not None: + request.reporting_data_annotation = reporting_data_annotation + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.create_reporting_data_annotation + ] + + # 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, + ) + + # Done; return the response. + return response + + def get_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.GetReportingDataAnnotationRequest, 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]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Lookup a single Reporting Data Annotation. + + Args: + request (Union[google.analytics.admin_v1alpha.types.GetReportingDataAnnotationRequest, dict]): + The request object. Request message for + GetReportingDataAnnotation RPC. + name (str): + Required. Resource name of the Reporting Data Annotation + to lookup. Format: + properties/property_id/reportingDataAnnotations/reportingDataAnnotation + Example: properties/123/reportingDataAnnotations/456 + + 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.analytics.admin_v1alpha.types.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + # 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, analytics_admin.GetReportingDataAnnotationRequest): + request = analytics_admin.GetReportingDataAnnotationRequest(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_reporting_data_annotation + ] + + # 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_reporting_data_annotations( + self, + request: Optional[ + Union[analytics_admin.ListReportingDataAnnotationsRequest, 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.ListReportingDataAnnotationsPager: + r"""List all Reporting Data Annotations on a property. + + Args: + request (Union[google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsRequest, dict]): + The request object. Request message for + ListReportingDataAnnotation RPC. + parent (str): + Required. Resource name of the property. Format: + properties/property_id Example: properties/123 + + 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.analytics.admin_v1alpha.services.analytics_admin_service.pagers.ListReportingDataAnnotationsPager: + Response message for + ListReportingDataAnnotation RPC. + 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, analytics_admin.ListReportingDataAnnotationsRequest): + request = analytics_admin.ListReportingDataAnnotationsRequest(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_reporting_data_annotations + ] + + # 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.ListReportingDataAnnotationsPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def update_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.UpdateReportingDataAnnotationRequest, dict] + ] = None, + *, + reporting_data_annotation: Optional[resources.ReportingDataAnnotation] = 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]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Updates a Reporting Data Annotation. + + Args: + request (Union[google.analytics.admin_v1alpha.types.UpdateReportingDataAnnotationRequest, dict]): + The request object. Request message for + UpdateReportingDataAnnotation RPC. + reporting_data_annotation (google.analytics.admin_v1alpha.types.ReportingDataAnnotation): + Required. The Reporting Data + Annotation to update. + + This corresponds to the ``reporting_data_annotation`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Optional. The list of fields to update. Field names must + be in snake case (for example, "field_to_update"). + Omitted fields will not be updated. To replace the + entire entity, use one path with the string "*" to match + all fields. + + 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.analytics.admin_v1alpha.types.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + # 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 = [reporting_data_annotation, 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, analytics_admin.UpdateReportingDataAnnotationRequest + ): + request = analytics_admin.UpdateReportingDataAnnotationRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if reporting_data_annotation is not None: + request.reporting_data_annotation = reporting_data_annotation + 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_reporting_data_annotation + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ( + "reporting_data_annotation.name", + request.reporting_data_annotation.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 delete_reporting_data_annotation( + self, + request: Optional[ + Union[analytics_admin.DeleteReportingDataAnnotationRequest, 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]]] = (), + ) -> None: + r"""Deletes a Reporting Data Annotation. + + Args: + request (Union[google.analytics.admin_v1alpha.types.DeleteReportingDataAnnotationRequest, dict]): + The request object. Request message for + DeleteReportingDataAnnotation RPC. + name (str): + Required. Resource name of the Reporting Data Annotation + to delete. Format: + properties/property_id/reportingDataAnnotations/reporting_data_annotation + Example: properties/123/reportingDataAnnotations/456 + + 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`. + """ + # 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, analytics_admin.DeleteReportingDataAnnotationRequest + ): + request = analytics_admin.DeleteReportingDataAnnotationRequest(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_reporting_data_annotation + ] + + # 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 submit_user_deletion( + self, + request: Optional[ + Union[analytics_admin.SubmitUserDeletionRequest, 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]]] = (), + ) -> analytics_admin.SubmitUserDeletionResponse: + r"""Submits a request for user deletion for a property. + + Args: + request (Union[google.analytics.admin_v1alpha.types.SubmitUserDeletionRequest, dict]): + The request object. Request message for + SubmitUserDeletion RPC. + name (str): + Required. The name of the property to + submit user deletion for. + + 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.analytics.admin_v1alpha.types.SubmitUserDeletionResponse: + Response message for + SubmitUserDeletion 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 = [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, analytics_admin.SubmitUserDeletionRequest): + request = analytics_admin.SubmitUserDeletionRequest(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.submit_user_deletion] + + # 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) -> "AnalyticsAdminServiceClient": return self diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/pagers.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/pagers.py index 4ae1f2cf164e..7f1453974c53 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/pagers.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/pagers.py @@ -4335,3 +4335,163 @@ async def async_generator(): def __repr__(self) -> str: return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListReportingDataAnnotationsPager: + """A pager for iterating through ``list_reporting_data_annotations`` requests. + + This class thinly wraps an initial + :class:`google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``reporting_data_annotations`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListReportingDataAnnotations`` requests and continue to iterate + through the ``reporting_data_annotations`` field on the + corresponding responses. + + All the usual :class:`google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsResponse` + 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[..., analytics_admin.ListReportingDataAnnotationsResponse], + request: analytics_admin.ListReportingDataAnnotationsRequest, + response: analytics_admin.ListReportingDataAnnotationsResponse, + *, + 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.analytics.admin_v1alpha.types.ListReportingDataAnnotationsRequest): + The initial request object. + response (google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsResponse): + 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 = analytics_admin.ListReportingDataAnnotationsRequest(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[analytics_admin.ListReportingDataAnnotationsResponse]: + 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.ReportingDataAnnotation]: + for page in self.pages: + yield from page.reporting_data_annotations + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListReportingDataAnnotationsAsyncPager: + """A pager for iterating through ``list_reporting_data_annotations`` requests. + + This class thinly wraps an initial + :class:`google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``reporting_data_annotations`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListReportingDataAnnotations`` requests and continue to iterate + through the ``reporting_data_annotations`` field on the + corresponding responses. + + All the usual :class:`google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsResponse` + 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[analytics_admin.ListReportingDataAnnotationsResponse] + ], + request: analytics_admin.ListReportingDataAnnotationsRequest, + response: analytics_admin.ListReportingDataAnnotationsResponse, + *, + 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.analytics.admin_v1alpha.types.ListReportingDataAnnotationsRequest): + The initial request object. + response (google.analytics.admin_v1alpha.types.ListReportingDataAnnotationsResponse): + 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 = analytics_admin.ListReportingDataAnnotationsRequest(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[analytics_admin.ListReportingDataAnnotationsResponse]: + 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.ReportingDataAnnotation]: + async def async_generator(): + async for page in self.pages: + for response in page.reporting_data_annotations: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/base.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/base.py index e446993b532f..b8756aa15999 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/base.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/base.py @@ -898,6 +898,36 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.create_reporting_data_annotation: gapic_v1.method.wrap_method( + self.create_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.get_reporting_data_annotation: gapic_v1.method.wrap_method( + self.get_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.list_reporting_data_annotations: gapic_v1.method.wrap_method( + self.list_reporting_data_annotations, + default_timeout=None, + client_info=client_info, + ), + self.update_reporting_data_annotation: gapic_v1.method.wrap_method( + self.update_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.delete_reporting_data_annotation: gapic_v1.method.wrap_method( + self.delete_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.submit_user_deletion: gapic_v1.method.wrap_method( + self.submit_user_deletion, + default_timeout=None, + client_info=client_info, + ), } def close(self): @@ -2486,6 +2516,75 @@ def delete_subproperty_event_filter( ]: raise NotImplementedError() + @property + def create_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.CreateReportingDataAnnotationRequest], + Union[ + resources.ReportingDataAnnotation, + Awaitable[resources.ReportingDataAnnotation], + ], + ]: + raise NotImplementedError() + + @property + def get_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.GetReportingDataAnnotationRequest], + Union[ + resources.ReportingDataAnnotation, + Awaitable[resources.ReportingDataAnnotation], + ], + ]: + raise NotImplementedError() + + @property + def list_reporting_data_annotations( + self, + ) -> Callable[ + [analytics_admin.ListReportingDataAnnotationsRequest], + Union[ + analytics_admin.ListReportingDataAnnotationsResponse, + Awaitable[analytics_admin.ListReportingDataAnnotationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def update_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.UpdateReportingDataAnnotationRequest], + Union[ + resources.ReportingDataAnnotation, + Awaitable[resources.ReportingDataAnnotation], + ], + ]: + raise NotImplementedError() + + @property + def delete_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.DeleteReportingDataAnnotationRequest], + Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], + ]: + raise NotImplementedError() + + @property + def submit_user_deletion( + self, + ) -> Callable[ + [analytics_admin.SubmitUserDeletionRequest], + Union[ + analytics_admin.SubmitUserDeletionResponse, + Awaitable[analytics_admin.SubmitUserDeletionResponse], + ], + ]: + raise NotImplementedError() + @property def kind(self) -> str: raise NotImplementedError() diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc.py index bde52e33e007..8120204db14a 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc.py @@ -4785,6 +4785,193 @@ def delete_subproperty_event_filter( ) return self._stubs["delete_subproperty_event_filter"] + @property + def create_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.CreateReportingDataAnnotationRequest], + resources.ReportingDataAnnotation, + ]: + r"""Return a callable for the create reporting data + annotation method over gRPC. + + Creates a Reporting Data Annotation. + + Returns: + Callable[[~.CreateReportingDataAnnotationRequest], + ~.ReportingDataAnnotation]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "create_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/CreateReportingDataAnnotation", + request_serializer=analytics_admin.CreateReportingDataAnnotationRequest.serialize, + response_deserializer=resources.ReportingDataAnnotation.deserialize, + ) + return self._stubs["create_reporting_data_annotation"] + + @property + def get_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.GetReportingDataAnnotationRequest], + resources.ReportingDataAnnotation, + ]: + r"""Return a callable for the get reporting data annotation method over gRPC. + + Lookup a single Reporting Data Annotation. + + Returns: + Callable[[~.GetReportingDataAnnotationRequest], + ~.ReportingDataAnnotation]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "get_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/GetReportingDataAnnotation", + request_serializer=analytics_admin.GetReportingDataAnnotationRequest.serialize, + response_deserializer=resources.ReportingDataAnnotation.deserialize, + ) + return self._stubs["get_reporting_data_annotation"] + + @property + def list_reporting_data_annotations( + self, + ) -> Callable[ + [analytics_admin.ListReportingDataAnnotationsRequest], + analytics_admin.ListReportingDataAnnotationsResponse, + ]: + r"""Return a callable for the list reporting data + annotations method over gRPC. + + List all Reporting Data Annotations on a property. + + Returns: + Callable[[~.ListReportingDataAnnotationsRequest], + ~.ListReportingDataAnnotationsResponse]: + 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_reporting_data_annotations" not in self._stubs: + self._stubs[ + "list_reporting_data_annotations" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/ListReportingDataAnnotations", + request_serializer=analytics_admin.ListReportingDataAnnotationsRequest.serialize, + response_deserializer=analytics_admin.ListReportingDataAnnotationsResponse.deserialize, + ) + return self._stubs["list_reporting_data_annotations"] + + @property + def update_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.UpdateReportingDataAnnotationRequest], + resources.ReportingDataAnnotation, + ]: + r"""Return a callable for the update reporting data + annotation method over gRPC. + + Updates a Reporting Data Annotation. + + Returns: + Callable[[~.UpdateReportingDataAnnotationRequest], + ~.ReportingDataAnnotation]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "update_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/UpdateReportingDataAnnotation", + request_serializer=analytics_admin.UpdateReportingDataAnnotationRequest.serialize, + response_deserializer=resources.ReportingDataAnnotation.deserialize, + ) + return self._stubs["update_reporting_data_annotation"] + + @property + def delete_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.DeleteReportingDataAnnotationRequest], empty_pb2.Empty + ]: + r"""Return a callable for the delete reporting data + annotation method over gRPC. + + Deletes a Reporting Data Annotation. + + Returns: + Callable[[~.DeleteReportingDataAnnotationRequest], + ~.Empty]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "delete_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/DeleteReportingDataAnnotation", + request_serializer=analytics_admin.DeleteReportingDataAnnotationRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_reporting_data_annotation"] + + @property + def submit_user_deletion( + self, + ) -> Callable[ + [analytics_admin.SubmitUserDeletionRequest], + analytics_admin.SubmitUserDeletionResponse, + ]: + r"""Return a callable for the submit user deletion method over gRPC. + + Submits a request for user deletion for a property. + + Returns: + Callable[[~.SubmitUserDeletionRequest], + ~.SubmitUserDeletionResponse]: + 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 "submit_user_deletion" not in self._stubs: + self._stubs["submit_user_deletion"] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/SubmitUserDeletion", + request_serializer=analytics_admin.SubmitUserDeletionRequest.serialize, + response_deserializer=analytics_admin.SubmitUserDeletionResponse.deserialize, + ) + return self._stubs["submit_user_deletion"] + def close(self): self._logged_channel.close() diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc_asyncio.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc_asyncio.py index 087087131952..356d5323b002 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc_asyncio.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/grpc_asyncio.py @@ -4900,6 +4900,194 @@ def delete_subproperty_event_filter( ) return self._stubs["delete_subproperty_event_filter"] + @property + def create_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.CreateReportingDataAnnotationRequest], + Awaitable[resources.ReportingDataAnnotation], + ]: + r"""Return a callable for the create reporting data + annotation method over gRPC. + + Creates a Reporting Data Annotation. + + Returns: + Callable[[~.CreateReportingDataAnnotationRequest], + Awaitable[~.ReportingDataAnnotation]]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "create_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/CreateReportingDataAnnotation", + request_serializer=analytics_admin.CreateReportingDataAnnotationRequest.serialize, + response_deserializer=resources.ReportingDataAnnotation.deserialize, + ) + return self._stubs["create_reporting_data_annotation"] + + @property + def get_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.GetReportingDataAnnotationRequest], + Awaitable[resources.ReportingDataAnnotation], + ]: + r"""Return a callable for the get reporting data annotation method over gRPC. + + Lookup a single Reporting Data Annotation. + + Returns: + Callable[[~.GetReportingDataAnnotationRequest], + Awaitable[~.ReportingDataAnnotation]]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "get_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/GetReportingDataAnnotation", + request_serializer=analytics_admin.GetReportingDataAnnotationRequest.serialize, + response_deserializer=resources.ReportingDataAnnotation.deserialize, + ) + return self._stubs["get_reporting_data_annotation"] + + @property + def list_reporting_data_annotations( + self, + ) -> Callable[ + [analytics_admin.ListReportingDataAnnotationsRequest], + Awaitable[analytics_admin.ListReportingDataAnnotationsResponse], + ]: + r"""Return a callable for the list reporting data + annotations method over gRPC. + + List all Reporting Data Annotations on a property. + + Returns: + Callable[[~.ListReportingDataAnnotationsRequest], + Awaitable[~.ListReportingDataAnnotationsResponse]]: + 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_reporting_data_annotations" not in self._stubs: + self._stubs[ + "list_reporting_data_annotations" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/ListReportingDataAnnotations", + request_serializer=analytics_admin.ListReportingDataAnnotationsRequest.serialize, + response_deserializer=analytics_admin.ListReportingDataAnnotationsResponse.deserialize, + ) + return self._stubs["list_reporting_data_annotations"] + + @property + def update_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.UpdateReportingDataAnnotationRequest], + Awaitable[resources.ReportingDataAnnotation], + ]: + r"""Return a callable for the update reporting data + annotation method over gRPC. + + Updates a Reporting Data Annotation. + + Returns: + Callable[[~.UpdateReportingDataAnnotationRequest], + Awaitable[~.ReportingDataAnnotation]]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "update_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/UpdateReportingDataAnnotation", + request_serializer=analytics_admin.UpdateReportingDataAnnotationRequest.serialize, + response_deserializer=resources.ReportingDataAnnotation.deserialize, + ) + return self._stubs["update_reporting_data_annotation"] + + @property + def delete_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.DeleteReportingDataAnnotationRequest], + Awaitable[empty_pb2.Empty], + ]: + r"""Return a callable for the delete reporting data + annotation method over gRPC. + + Deletes a Reporting Data Annotation. + + Returns: + Callable[[~.DeleteReportingDataAnnotationRequest], + Awaitable[~.Empty]]: + 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_reporting_data_annotation" not in self._stubs: + self._stubs[ + "delete_reporting_data_annotation" + ] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/DeleteReportingDataAnnotation", + request_serializer=analytics_admin.DeleteReportingDataAnnotationRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_reporting_data_annotation"] + + @property + def submit_user_deletion( + self, + ) -> Callable[ + [analytics_admin.SubmitUserDeletionRequest], + Awaitable[analytics_admin.SubmitUserDeletionResponse], + ]: + r"""Return a callable for the submit user deletion method over gRPC. + + Submits a request for user deletion for a property. + + Returns: + Callable[[~.SubmitUserDeletionRequest], + Awaitable[~.SubmitUserDeletionResponse]]: + 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 "submit_user_deletion" not in self._stubs: + self._stubs["submit_user_deletion"] = self._logged_channel.unary_unary( + "/google.analytics.admin.v1alpha.AnalyticsAdminService/SubmitUserDeletion", + request_serializer=analytics_admin.SubmitUserDeletionRequest.serialize, + response_deserializer=analytics_admin.SubmitUserDeletionResponse.deserialize, + ) + return self._stubs["submit_user_deletion"] + def _prep_wrapped_messages(self, client_info): """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" self._wrapped_methods = { @@ -5653,6 +5841,36 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.create_reporting_data_annotation: self._wrap_method( + self.create_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.get_reporting_data_annotation: self._wrap_method( + self.get_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.list_reporting_data_annotations: self._wrap_method( + self.list_reporting_data_annotations, + default_timeout=None, + client_info=client_info, + ), + self.update_reporting_data_annotation: self._wrap_method( + self.update_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.delete_reporting_data_annotation: self._wrap_method( + self.delete_reporting_data_annotation, + default_timeout=None, + client_info=client_info, + ), + self.submit_user_deletion: self._wrap_method( + self.submit_user_deletion, + default_timeout=None, + client_info=client_info, + ), } def _wrap_method(self, func, *args, **kwargs): diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest.py index afb939b5df09..f8c8131d1777 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest.py @@ -315,6 +315,14 @@ def post_create_property(self, response): logging.log(f"Received response: {response}") return response + def pre_create_reporting_data_annotation(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_reporting_data_annotation(self, response): + logging.log(f"Received response: {response}") + return response + def pre_create_rollup_property(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -435,6 +443,10 @@ def post_delete_property(self, response): logging.log(f"Received response: {response}") return response + def pre_delete_reporting_data_annotation(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + def pre_delete_rollup_property_source_link(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -675,6 +687,14 @@ def post_get_property(self, response): logging.log(f"Received response: {response}") return response + def pre_get_reporting_data_annotation(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_reporting_data_annotation(self, response): + logging.log(f"Received response: {response}") + return response + def pre_get_rollup_property_source_link(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -891,6 +911,14 @@ def post_list_properties(self, response): logging.log(f"Received response: {response}") return response + def pre_list_reporting_data_annotations(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_reporting_data_annotations(self, response): + logging.log(f"Received response: {response}") + return response + def pre_list_rollup_property_source_links(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -967,6 +995,14 @@ def post_set_automated_ga4_configuration_opt_out(self, response): logging.log(f"Received response: {response}") return response + def pre_submit_user_deletion(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_submit_user_deletion(self, response): + logging.log(f"Received response: {response}") + return response + def pre_update_access_binding(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -1151,6 +1187,14 @@ def post_update_property(self, response): logging.log(f"Received response: {response}") return response + def pre_update_reporting_data_annotation(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_reporting_data_annotation(self, response): + logging.log(f"Received response: {response}") + return response + def pre_update_search_ads360_link(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -2590,6 +2634,57 @@ def post_create_property_with_metadata( """ return response, metadata + def pre_create_reporting_data_annotation( + self, + request: analytics_admin.CreateReportingDataAnnotationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.CreateReportingDataAnnotationRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for create_reporting_data_annotation + + Override in a subclass to manipulate the request or metadata + before they are sent to the AnalyticsAdminService server. + """ + return request, metadata + + def post_create_reporting_data_annotation( + self, response: resources.ReportingDataAnnotation + ) -> resources.ReportingDataAnnotation: + """Post-rpc interceptor for create_reporting_data_annotation + + DEPRECATED. Please use the `post_create_reporting_data_annotation_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the AnalyticsAdminService server but before + it is returned to user code. This `post_create_reporting_data_annotation` interceptor runs + before the `post_create_reporting_data_annotation_with_metadata` interceptor. + """ + return response + + def post_create_reporting_data_annotation_with_metadata( + self, + response: resources.ReportingDataAnnotation, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + resources.ReportingDataAnnotation, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for create_reporting_data_annotation + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the AnalyticsAdminService server but before it is returned to user code. + + We recommend only using this `post_create_reporting_data_annotation_with_metadata` + interceptor in new development instead of the `post_create_reporting_data_annotation` interceptor. + When both interceptors are used, this `post_create_reporting_data_annotation_with_metadata` interceptor runs after the + `post_create_reporting_data_annotation` interceptor. The (possibly modified) response returned by + `post_create_reporting_data_annotation` will be passed to + `post_create_reporting_data_annotation_with_metadata`. + """ + return response, metadata + def pre_create_rollup_property( self, request: analytics_admin.CreateRollupPropertyRequest, @@ -3159,6 +3254,21 @@ def post_delete_property_with_metadata( """ return response, metadata + def pre_delete_reporting_data_annotation( + self, + request: analytics_admin.DeleteReportingDataAnnotationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.DeleteReportingDataAnnotationRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for delete_reporting_data_annotation + + Override in a subclass to manipulate the request or metadata + before they are sent to the AnalyticsAdminService server. + """ + return request, metadata + def pre_delete_rollup_property_source_link( self, request: analytics_admin.DeleteRollupPropertySourceLinkRequest, @@ -4598,6 +4708,57 @@ def post_get_property_with_metadata( """ return response, metadata + def pre_get_reporting_data_annotation( + self, + request: analytics_admin.GetReportingDataAnnotationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.GetReportingDataAnnotationRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for get_reporting_data_annotation + + Override in a subclass to manipulate the request or metadata + before they are sent to the AnalyticsAdminService server. + """ + return request, metadata + + def post_get_reporting_data_annotation( + self, response: resources.ReportingDataAnnotation + ) -> resources.ReportingDataAnnotation: + """Post-rpc interceptor for get_reporting_data_annotation + + DEPRECATED. Please use the `post_get_reporting_data_annotation_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the AnalyticsAdminService server but before + it is returned to user code. This `post_get_reporting_data_annotation` interceptor runs + before the `post_get_reporting_data_annotation_with_metadata` interceptor. + """ + return response + + def post_get_reporting_data_annotation_with_metadata( + self, + response: resources.ReportingDataAnnotation, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + resources.ReportingDataAnnotation, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for get_reporting_data_annotation + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the AnalyticsAdminService server but before it is returned to user code. + + We recommend only using this `post_get_reporting_data_annotation_with_metadata` + interceptor in new development instead of the `post_get_reporting_data_annotation` interceptor. + When both interceptors are used, this `post_get_reporting_data_annotation_with_metadata` interceptor runs after the + `post_get_reporting_data_annotation` interceptor. The (possibly modified) response returned by + `post_get_reporting_data_annotation` will be passed to + `post_get_reporting_data_annotation_with_metadata`. + """ + return response, metadata + def pre_get_rollup_property_source_link( self, request: analytics_admin.GetRollupPropertySourceLinkRequest, @@ -5988,6 +6149,58 @@ def post_list_properties_with_metadata( """ return response, metadata + def pre_list_reporting_data_annotations( + self, + request: analytics_admin.ListReportingDataAnnotationsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.ListReportingDataAnnotationsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for list_reporting_data_annotations + + Override in a subclass to manipulate the request or metadata + before they are sent to the AnalyticsAdminService server. + """ + return request, metadata + + def post_list_reporting_data_annotations( + self, response: analytics_admin.ListReportingDataAnnotationsResponse + ) -> analytics_admin.ListReportingDataAnnotationsResponse: + """Post-rpc interceptor for list_reporting_data_annotations + + DEPRECATED. Please use the `post_list_reporting_data_annotations_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the AnalyticsAdminService server but before + it is returned to user code. This `post_list_reporting_data_annotations` interceptor runs + before the `post_list_reporting_data_annotations_with_metadata` interceptor. + """ + return response + + def post_list_reporting_data_annotations_with_metadata( + self, + response: analytics_admin.ListReportingDataAnnotationsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.ListReportingDataAnnotationsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for list_reporting_data_annotations + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the AnalyticsAdminService server but before it is returned to user code. + + We recommend only using this `post_list_reporting_data_annotations_with_metadata` + interceptor in new development instead of the `post_list_reporting_data_annotations` interceptor. + When both interceptors are used, this `post_list_reporting_data_annotations_with_metadata` interceptor runs after the + `post_list_reporting_data_annotations` interceptor. The (possibly modified) response returned by + `post_list_reporting_data_annotations` will be passed to + `post_list_reporting_data_annotations_with_metadata`. + """ + return response, metadata + def pre_list_rollup_property_source_links( self, request: analytics_admin.ListRollupPropertySourceLinksRequest, @@ -6469,6 +6682,58 @@ def post_set_automated_ga4_configuration_opt_out_with_metadata( """ return response, metadata + def pre_submit_user_deletion( + self, + request: analytics_admin.SubmitUserDeletionRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.SubmitUserDeletionRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for submit_user_deletion + + Override in a subclass to manipulate the request or metadata + before they are sent to the AnalyticsAdminService server. + """ + return request, metadata + + def post_submit_user_deletion( + self, response: analytics_admin.SubmitUserDeletionResponse + ) -> analytics_admin.SubmitUserDeletionResponse: + """Post-rpc interceptor for submit_user_deletion + + DEPRECATED. Please use the `post_submit_user_deletion_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the AnalyticsAdminService server but before + it is returned to user code. This `post_submit_user_deletion` interceptor runs + before the `post_submit_user_deletion_with_metadata` interceptor. + """ + return response + + def post_submit_user_deletion_with_metadata( + self, + response: analytics_admin.SubmitUserDeletionResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.SubmitUserDeletionResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for submit_user_deletion + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the AnalyticsAdminService server but before it is returned to user code. + + We recommend only using this `post_submit_user_deletion_with_metadata` + interceptor in new development instead of the `post_submit_user_deletion` interceptor. + When both interceptors are used, this `post_submit_user_deletion_with_metadata` interceptor runs after the + `post_submit_user_deletion` interceptor. The (possibly modified) response returned by + `post_submit_user_deletion` will be passed to + `post_submit_user_deletion_with_metadata`. + """ + return response, metadata + def pre_update_access_binding( self, request: analytics_admin.UpdateAccessBindingRequest, @@ -7603,6 +7868,57 @@ def post_update_property_with_metadata( """ return response, metadata + def pre_update_reporting_data_annotation( + self, + request: analytics_admin.UpdateReportingDataAnnotationRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + analytics_admin.UpdateReportingDataAnnotationRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for update_reporting_data_annotation + + Override in a subclass to manipulate the request or metadata + before they are sent to the AnalyticsAdminService server. + """ + return request, metadata + + def post_update_reporting_data_annotation( + self, response: resources.ReportingDataAnnotation + ) -> resources.ReportingDataAnnotation: + """Post-rpc interceptor for update_reporting_data_annotation + + DEPRECATED. Please use the `post_update_reporting_data_annotation_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the AnalyticsAdminService server but before + it is returned to user code. This `post_update_reporting_data_annotation` interceptor runs + before the `post_update_reporting_data_annotation_with_metadata` interceptor. + """ + return response + + def post_update_reporting_data_annotation_with_metadata( + self, + response: resources.ReportingDataAnnotation, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + resources.ReportingDataAnnotation, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for update_reporting_data_annotation + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the AnalyticsAdminService server but before it is returned to user code. + + We recommend only using this `post_update_reporting_data_annotation_with_metadata` + interceptor in new development instead of the `post_update_reporting_data_annotation` interceptor. + When both interceptors are used, this `post_update_reporting_data_annotation_with_metadata` interceptor runs after the + `post_update_reporting_data_annotation` interceptor. The (possibly modified) response returned by + `post_update_reporting_data_annotation` will be passed to + `post_update_reporting_data_annotation_with_metadata`. + """ + return response, metadata + def pre_update_search_ads360_link( self, request: analytics_admin.UpdateSearchAds360LinkRequest, @@ -12683,12 +12999,14 @@ def __call__( ) return resp - class _CreateRollupProperty( - _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty, + class _CreateReportingDataAnnotation( + _BaseAnalyticsAdminServiceRestTransport._BaseCreateReportingDataAnnotation, AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash("AnalyticsAdminServiceRestTransport.CreateRollupProperty") + return hash( + "AnalyticsAdminServiceRestTransport.CreateReportingDataAnnotation" + ) @staticmethod def _get_response( @@ -12715,50 +13033,52 @@ def _get_response( def __call__( self, - request: analytics_admin.CreateRollupPropertyRequest, + request: analytics_admin.CreateReportingDataAnnotationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> analytics_admin.CreateRollupPropertyResponse: - r"""Call the create rollup property method over HTTP. + ) -> resources.ReportingDataAnnotation: + r"""Call the create reporting data + annotation method over HTTP. - Args: - request (~.analytics_admin.CreateRollupPropertyRequest): - The request object. Request message for - CreateRollupProperty 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`. + Args: + request (~.analytics_admin.CreateReportingDataAnnotationRequest): + The request object. Request message for + CreateReportingDataAnnotation 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: - ~.analytics_admin.CreateRollupPropertyResponse: - Response message for - CreateRollupProperty RPC. + Returns: + ~.resources.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. """ http_options = ( - _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_http_options() + _BaseAnalyticsAdminServiceRestTransport._BaseCreateReportingDataAnnotation._get_http_options() ) - request, metadata = self._interceptor.pre_create_rollup_property( + request, metadata = self._interceptor.pre_create_reporting_data_annotation( request, metadata ) - transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_transcoded_request( + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseCreateReportingDataAnnotation._get_transcoded_request( http_options, request ) - body = _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_request_body_json( + body = _BaseAnalyticsAdminServiceRestTransport._BaseCreateReportingDataAnnotation._get_request_body_json( transcoded_request ) # Jsonify the query params - query_params = _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_query_params_json( + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseCreateReportingDataAnnotation._get_query_params_json( transcoded_request ) @@ -12780,26 +13100,24 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.CreateRollupProperty", + f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.CreateReportingDataAnnotation", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "CreateRollupProperty", + "rpcName": "CreateReportingDataAnnotation", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ( - AnalyticsAdminServiceRestTransport._CreateRollupProperty._get_response( - self._host, - metadata, - query_params, - self._session, - timeout, - transcoded_request, - body, - ) + response = AnalyticsAdminServiceRestTransport._CreateReportingDataAnnotation._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -12808,12 +13126,175 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = analytics_admin.CreateRollupPropertyResponse() - pb_resp = analytics_admin.CreateRollupPropertyResponse.pb(resp) + resp = resources.ReportingDataAnnotation() + pb_resp = resources.ReportingDataAnnotation.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_create_rollup_property(resp) + resp = self._interceptor.post_create_reporting_data_annotation(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_create_reporting_data_annotation_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = resources.ReportingDataAnnotation.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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.create_reporting_data_annotation", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "CreateReportingDataAnnotation", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _CreateRollupProperty( + _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty, + AnalyticsAdminServiceRestStub, + ): + def __hash__(self): + return hash("AnalyticsAdminServiceRestTransport.CreateRollupProperty") + + @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: analytics_admin.CreateRollupPropertyRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> analytics_admin.CreateRollupPropertyResponse: + r"""Call the create rollup property method over HTTP. + + Args: + request (~.analytics_admin.CreateRollupPropertyRequest): + The request object. Request message for + CreateRollupProperty 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: + ~.analytics_admin.CreateRollupPropertyResponse: + Response message for + CreateRollupProperty RPC. + + """ + + http_options = ( + _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_http_options() + ) + + request, metadata = self._interceptor.pre_create_rollup_property( + request, metadata + ) + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_transcoded_request( + http_options, request + ) + + body = _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseCreateRollupProperty._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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.CreateRollupProperty", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "CreateRollupProperty", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + AnalyticsAdminServiceRestTransport._CreateRollupProperty._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 = analytics_admin.CreateRollupPropertyResponse() + pb_resp = analytics_admin.CreateRollupPropertyResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_create_rollup_property(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_rollup_property_with_metadata( resp, response_metadata @@ -15677,13 +16158,13 @@ def __call__( ) return resp - class _DeleteRollupPropertySourceLink( - _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink, + class _DeleteReportingDataAnnotation( + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteReportingDataAnnotation, AnalyticsAdminServiceRestStub, ): def __hash__(self): return hash( - "AnalyticsAdminServiceRestTransport.DeleteRollupPropertySourceLink" + "AnalyticsAdminServiceRestTransport.DeleteReportingDataAnnotation" ) @staticmethod @@ -15710,19 +16191,19 @@ def _get_response( def __call__( self, - request: analytics_admin.DeleteRollupPropertySourceLinkRequest, + request: analytics_admin.DeleteReportingDataAnnotationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), ): - r"""Call the delete rollup property - source link method over HTTP. + r"""Call the delete reporting data + annotation method over HTTP. Args: - request (~.analytics_admin.DeleteRollupPropertySourceLinkRequest): + request (~.analytics_admin.DeleteReportingDataAnnotationRequest): The request object. Request message for - DeleteRollupPropertySourceLink RPC. + DeleteReportingDataAnnotation RPC. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -15733,21 +16214,18 @@ def __call__( """ http_options = ( - _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink._get_http_options() + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteReportingDataAnnotation._get_http_options() ) - ( - request, - metadata, - ) = self._interceptor.pre_delete_rollup_property_source_link( + request, metadata = self._interceptor.pre_delete_reporting_data_annotation( request, metadata ) - transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink._get_transcoded_request( + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteReportingDataAnnotation._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink._get_query_params_json( + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteReportingDataAnnotation._get_query_params_json( transcoded_request ) @@ -15769,17 +16247,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.DeleteRollupPropertySourceLink", + f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.DeleteReportingDataAnnotation", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "DeleteRollupPropertySourceLink", + "rpcName": "DeleteReportingDataAnnotation", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = AnalyticsAdminServiceRestTransport._DeleteRollupPropertySourceLink._get_response( + response = AnalyticsAdminServiceRestTransport._DeleteReportingDataAnnotation._get_response( self._host, metadata, query_params, @@ -15793,12 +16271,14 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) - class _DeleteSearchAds360Link( - _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link, + class _DeleteRollupPropertySourceLink( + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink, AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash("AnalyticsAdminServiceRestTransport.DeleteSearchAds360Link") + return hash( + "AnalyticsAdminServiceRestTransport.DeleteRollupPropertySourceLink" + ) @staticmethod def _get_response( @@ -15824,40 +16304,44 @@ def _get_response( def __call__( self, - request: analytics_admin.DeleteSearchAds360LinkRequest, + request: analytics_admin.DeleteRollupPropertySourceLinkRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), ): - r"""Call the delete search ads360 link method over HTTP. + r"""Call the delete rollup property + source link method over HTTP. - Args: - request (~.analytics_admin.DeleteSearchAds360LinkRequest): - The request object. Request message for - DeleteSearchAds360Link 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`. + Args: + request (~.analytics_admin.DeleteRollupPropertySourceLinkRequest): + The request object. Request message for + DeleteRollupPropertySourceLink 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`. """ http_options = ( - _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link._get_http_options() + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink._get_http_options() ) - request, metadata = self._interceptor.pre_delete_search_ads360_link( + ( + request, + metadata, + ) = self._interceptor.pre_delete_rollup_property_source_link( request, metadata ) - transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link._get_transcoded_request( + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link._get_query_params_json( + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteRollupPropertySourceLink._get_query_params_json( transcoded_request ) @@ -15879,17 +16363,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.DeleteSearchAds360Link", + f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.DeleteRollupPropertySourceLink", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "DeleteSearchAds360Link", + "rpcName": "DeleteRollupPropertySourceLink", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = AnalyticsAdminServiceRestTransport._DeleteSearchAds360Link._get_response( + response = AnalyticsAdminServiceRestTransport._DeleteRollupPropertySourceLink._get_response( self._host, metadata, query_params, @@ -15903,14 +16387,12 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) - class _DeleteSKAdNetworkConversionValueSchema( - _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSKAdNetworkConversionValueSchema, + class _DeleteSearchAds360Link( + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link, AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash( - "AnalyticsAdminServiceRestTransport.DeleteSKAdNetworkConversionValueSchema" - ) + return hash("AnalyticsAdminServiceRestTransport.DeleteSearchAds360Link") @staticmethod def _get_response( @@ -15936,28 +16418,140 @@ def _get_response( def __call__( self, - request: analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, + request: analytics_admin.DeleteSearchAds360LinkRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), ): - r"""Call the delete sk ad network - conversion value schema method over HTTP. - - Args: - request (~.analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest): - The request object. Request message for - DeleteSKAdNetworkConversionValueSchema - 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`. - """ + r"""Call the delete search ads360 link method over HTTP. + + Args: + request (~.analytics_admin.DeleteSearchAds360LinkRequest): + The request object. Request message for + DeleteSearchAds360Link 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`. + """ + + http_options = ( + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_search_ads360_link( + request, metadata + ) + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSearchAds360Link._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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.DeleteSearchAds360Link", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "DeleteSearchAds360Link", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = AnalyticsAdminServiceRestTransport._DeleteSearchAds360Link._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) + + class _DeleteSKAdNetworkConversionValueSchema( + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSKAdNetworkConversionValueSchema, + AnalyticsAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "AnalyticsAdminServiceRestTransport.DeleteSKAdNetworkConversionValueSchema" + ) + + @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: analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ): + r"""Call the delete sk ad network + conversion value schema method over HTTP. + + Args: + request (~.analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest): + The request object. Request message for + DeleteSKAdNetworkConversionValueSchema + 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`. + """ http_options = ( _BaseAnalyticsAdminServiceRestTransport._BaseDeleteSKAdNetworkConversionValueSchema._get_http_options() @@ -20454,14 +21048,12 @@ def __call__( ) return resp - class _GetRollupPropertySourceLink( - _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink, + class _GetReportingDataAnnotation( + _BaseAnalyticsAdminServiceRestTransport._BaseGetReportingDataAnnotation, AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash( - "AnalyticsAdminServiceRestTransport.GetRollupPropertySourceLink" - ) + return hash("AnalyticsAdminServiceRestTransport.GetReportingDataAnnotation") @staticmethod def _get_response( @@ -20487,19 +21079,19 @@ def _get_response( def __call__( self, - request: analytics_admin.GetRollupPropertySourceLinkRequest, + request: analytics_admin.GetReportingDataAnnotationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> resources.RollupPropertySourceLink: - r"""Call the get rollup property - source link method over HTTP. + ) -> resources.ReportingDataAnnotation: + r"""Call the get reporting data + annotation method over HTTP. Args: - request (~.analytics_admin.GetRollupPropertySourceLinkRequest): + request (~.analytics_admin.GetReportingDataAnnotationRequest): The request object. Request message for - GetRollupPropertySourceLink RPC. + GetReportingDataAnnotation RPC. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -20509,26 +21101,26 @@ def __call__( be of type `bytes`. Returns: - ~.resources.RollupPropertySourceLink: - A link that references a source - property under the parent rollup - property. + ~.resources.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. """ http_options = ( - _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink._get_http_options() + _BaseAnalyticsAdminServiceRestTransport._BaseGetReportingDataAnnotation._get_http_options() ) - request, metadata = self._interceptor.pre_get_rollup_property_source_link( + request, metadata = self._interceptor.pre_get_reporting_data_annotation( request, metadata ) - transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink._get_transcoded_request( + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseGetReportingDataAnnotation._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink._get_query_params_json( + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseGetReportingDataAnnotation._get_query_params_json( transcoded_request ) @@ -20550,17 +21142,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.GetRollupPropertySourceLink", + f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.GetReportingDataAnnotation", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "GetRollupPropertySourceLink", + "rpcName": "GetReportingDataAnnotation", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = AnalyticsAdminServiceRestTransport._GetRollupPropertySourceLink._get_response( + response = AnalyticsAdminServiceRestTransport._GetReportingDataAnnotation._get_response( self._host, metadata, query_params, @@ -20575,24 +21167,24 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = resources.RollupPropertySourceLink() - pb_resp = resources.RollupPropertySourceLink.pb(resp) + resp = resources.ReportingDataAnnotation() + pb_resp = resources.ReportingDataAnnotation.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_rollup_property_source_link(resp) + resp = self._interceptor.post_get_reporting_data_annotation(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] ( resp, _, - ) = self._interceptor.post_get_rollup_property_source_link_with_metadata( + ) = self._interceptor.post_get_reporting_data_annotation_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = resources.RollupPropertySourceLink.to_json( + response_payload = resources.ReportingDataAnnotation.to_json( response ) except: @@ -20603,22 +21195,24 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.get_rollup_property_source_link", + "Received response for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.get_reporting_data_annotation", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "GetRollupPropertySourceLink", + "rpcName": "GetReportingDataAnnotation", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _GetSearchAds360Link( - _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link, + class _GetRollupPropertySourceLink( + _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink, AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash("AnalyticsAdminServiceRestTransport.GetSearchAds360Link") + return hash( + "AnalyticsAdminServiceRestTransport.GetRollupPropertySourceLink" + ) @staticmethod def _get_response( @@ -20644,46 +21238,48 @@ def _get_response( def __call__( self, - request: analytics_admin.GetSearchAds360LinkRequest, + request: analytics_admin.GetRollupPropertySourceLinkRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> resources.SearchAds360Link: - r"""Call the get search ads360 link method over HTTP. + ) -> resources.RollupPropertySourceLink: + r"""Call the get rollup property + source link method over HTTP. - Args: - request (~.analytics_admin.GetSearchAds360LinkRequest): - The request object. Request message for - GetSearchAds360Link 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`. + Args: + request (~.analytics_admin.GetRollupPropertySourceLinkRequest): + The request object. Request message for + GetRollupPropertySourceLink 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: - ~.resources.SearchAds360Link: - A link between a Google Analytics - property and a Search Ads 360 entity. + Returns: + ~.resources.RollupPropertySourceLink: + A link that references a source + property under the parent rollup + property. """ http_options = ( - _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link._get_http_options() + _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink._get_http_options() ) - request, metadata = self._interceptor.pre_get_search_ads360_link( + request, metadata = self._interceptor.pre_get_rollup_property_source_link( request, metadata ) - transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link._get_transcoded_request( + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link._get_query_params_json( + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseGetRollupPropertySourceLink._get_query_params_json( transcoded_request ) @@ -20705,25 +21301,23 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.GetSearchAds360Link", + f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.GetRollupPropertySourceLink", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "GetSearchAds360Link", + "rpcName": "GetRollupPropertySourceLink", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ( - AnalyticsAdminServiceRestTransport._GetSearchAds360Link._get_response( - self._host, - metadata, - query_params, - self._session, - timeout, - transcoded_request, - ) + response = AnalyticsAdminServiceRestTransport._GetRollupPropertySourceLink._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -20732,21 +21326,26 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = resources.SearchAds360Link() - pb_resp = resources.SearchAds360Link.pb(resp) + resp = resources.RollupPropertySourceLink() + pb_resp = resources.RollupPropertySourceLink.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_search_ads360_link(resp) + resp = self._interceptor.post_get_rollup_property_source_link(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_search_ads360_link_with_metadata( + ( + resp, + _, + ) = self._interceptor.post_get_rollup_property_source_link_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = resources.SearchAds360Link.to_json(response) + response_payload = resources.RollupPropertySourceLink.to_json( + response + ) except: response_payload = None http_response = { @@ -20755,24 +21354,176 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.get_search_ads360_link", + "Received response for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.get_rollup_property_source_link", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "GetSearchAds360Link", + "rpcName": "GetRollupPropertySourceLink", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _GetSKAdNetworkConversionValueSchema( - _BaseAnalyticsAdminServiceRestTransport._BaseGetSKAdNetworkConversionValueSchema, + class _GetSearchAds360Link( + _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link, AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash( - "AnalyticsAdminServiceRestTransport.GetSKAdNetworkConversionValueSchema" - ) + return hash("AnalyticsAdminServiceRestTransport.GetSearchAds360Link") + + @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: analytics_admin.GetSearchAds360LinkRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> resources.SearchAds360Link: + r"""Call the get search ads360 link method over HTTP. + + Args: + request (~.analytics_admin.GetSearchAds360LinkRequest): + The request object. Request message for + GetSearchAds360Link 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: + ~.resources.SearchAds360Link: + A link between a Google Analytics + property and a Search Ads 360 entity. + + """ + + http_options = ( + _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_search_ads360_link( + request, metadata + ) + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseGetSearchAds360Link._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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.GetSearchAds360Link", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "GetSearchAds360Link", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + AnalyticsAdminServiceRestTransport._GetSearchAds360Link._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 = resources.SearchAds360Link() + pb_resp = resources.SearchAds360Link.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_get_search_ads360_link(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_get_search_ads360_link_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = resources.SearchAds360Link.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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.get_search_ads360_link", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "GetSearchAds360Link", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetSKAdNetworkConversionValueSchema( + _BaseAnalyticsAdminServiceRestTransport._BaseGetSKAdNetworkConversionValueSchema, + AnalyticsAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "AnalyticsAdminServiceRestTransport.GetSKAdNetworkConversionValueSchema" + ) @staticmethod def _get_response( @@ -24644,6 +25395,166 @@ def __call__( ) return resp + class _ListReportingDataAnnotations( + _BaseAnalyticsAdminServiceRestTransport._BaseListReportingDataAnnotations, + AnalyticsAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "AnalyticsAdminServiceRestTransport.ListReportingDataAnnotations" + ) + + @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: analytics_admin.ListReportingDataAnnotationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> analytics_admin.ListReportingDataAnnotationsResponse: + r"""Call the list reporting data + annotations method over HTTP. + + Args: + request (~.analytics_admin.ListReportingDataAnnotationsRequest): + The request object. Request message for + ListReportingDataAnnotation 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: + ~.analytics_admin.ListReportingDataAnnotationsResponse: + Response message for + ListReportingDataAnnotation RPC. + + """ + + http_options = ( + _BaseAnalyticsAdminServiceRestTransport._BaseListReportingDataAnnotations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_reporting_data_annotations( + request, metadata + ) + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseListReportingDataAnnotations._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseListReportingDataAnnotations._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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.ListReportingDataAnnotations", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "ListReportingDataAnnotations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = AnalyticsAdminServiceRestTransport._ListReportingDataAnnotations._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 = analytics_admin.ListReportingDataAnnotationsResponse() + pb_resp = analytics_admin.ListReportingDataAnnotationsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_reporting_data_annotations(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_list_reporting_data_annotations_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + analytics_admin.ListReportingDataAnnotationsResponse.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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.list_reporting_data_annotations", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "ListReportingDataAnnotations", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + class _ListRollupPropertySourceLinks( _BaseAnalyticsAdminServiceRestTransport._BaseListRollupPropertySourceLinks, AnalyticsAdminServiceRestStub, @@ -26047,9 +26958,178 @@ class _SetAutomatedGa4ConfigurationOptOut( AnalyticsAdminServiceRestStub, ): def __hash__(self): - return hash( - "AnalyticsAdminServiceRestTransport.SetAutomatedGa4ConfigurationOptOut" - ) + return hash( + "AnalyticsAdminServiceRestTransport.SetAutomatedGa4ConfigurationOptOut" + ) + + @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: analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse: + r"""Call the set automated ga4 + configuration opt out method over HTTP. + + Args: + request (~.analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest): + The request object. Request for setting the opt out + status for the automated GA4 setup + process. + 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: + ~.analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse: + Response message for setting the opt + out status for the automated GA4 setup + process. + + """ + + http_options = ( + _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_http_options() + ) + + ( + request, + metadata, + ) = self._interceptor.pre_set_automated_ga4_configuration_opt_out( + request, metadata + ) + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_transcoded_request( + http_options, request + ) + + body = _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.SetAutomatedGa4ConfigurationOptOut", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "SetAutomatedGa4ConfigurationOptOut", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = AnalyticsAdminServiceRestTransport._SetAutomatedGa4ConfigurationOptOut._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 = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + pb_resp = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.pb( + resp + ) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_set_automated_ga4_configuration_opt_out(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_set_automated_ga4_configuration_opt_out_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.set_automated_ga4_configuration_opt_out", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "SetAutomatedGa4ConfigurationOptOut", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _SubmitUserDeletion( + _BaseAnalyticsAdminServiceRestTransport._BaseSubmitUserDeletion, + AnalyticsAdminServiceRestStub, + ): + def __hash__(self): + return hash("AnalyticsAdminServiceRestTransport.SubmitUserDeletion") @staticmethod def _get_response( @@ -26076,56 +27156,50 @@ def _get_response( def __call__( self, - request: analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, + request: analytics_admin.SubmitUserDeletionRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse: - r"""Call the set automated ga4 - configuration opt out method over HTTP. + ) -> analytics_admin.SubmitUserDeletionResponse: + r"""Call the submit user deletion method over HTTP. - Args: - request (~.analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest): - The request object. Request for setting the opt out - status for the automated GA4 setup - process. - 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`. + Args: + request (~.analytics_admin.SubmitUserDeletionRequest): + The request object. Request message for + SubmitUserDeletion 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: - ~.analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse: - Response message for setting the opt - out status for the automated GA4 setup - process. + Returns: + ~.analytics_admin.SubmitUserDeletionResponse: + Response message for + SubmitUserDeletion RPC. """ http_options = ( - _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_http_options() + _BaseAnalyticsAdminServiceRestTransport._BaseSubmitUserDeletion._get_http_options() ) - ( - request, - metadata, - ) = self._interceptor.pre_set_automated_ga4_configuration_opt_out( + request, metadata = self._interceptor.pre_submit_user_deletion( request, metadata ) - transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_transcoded_request( + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseSubmitUserDeletion._get_transcoded_request( http_options, request ) - body = _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_request_body_json( + body = _BaseAnalyticsAdminServiceRestTransport._BaseSubmitUserDeletion._get_request_body_json( transcoded_request ) # Jsonify the query params - query_params = _BaseAnalyticsAdminServiceRestTransport._BaseSetAutomatedGa4ConfigurationOptOut._get_query_params_json( + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseSubmitUserDeletion._get_query_params_json( transcoded_request ) @@ -26147,24 +27221,26 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.SetAutomatedGa4ConfigurationOptOut", + f"Sending request for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.SubmitUserDeletion", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "SetAutomatedGa4ConfigurationOptOut", + "rpcName": "SubmitUserDeletion", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = AnalyticsAdminServiceRestTransport._SetAutomatedGa4ConfigurationOptOut._get_response( - self._host, - metadata, - query_params, - self._session, - timeout, - transcoded_request, - body, + response = ( + AnalyticsAdminServiceRestTransport._SubmitUserDeletion._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -26173,27 +27249,22 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() - pb_resp = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.pb( - resp - ) + resp = analytics_admin.SubmitUserDeletionResponse() + pb_resp = analytics_admin.SubmitUserDeletionResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_set_automated_ga4_configuration_opt_out(resp) + resp = self._interceptor.post_submit_user_deletion(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - ( - resp, - _, - ) = self._interceptor.post_set_automated_ga4_configuration_opt_out_with_metadata( + resp, _ = self._interceptor.post_submit_user_deletion_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.to_json( - response + response_payload = ( + analytics_admin.SubmitUserDeletionResponse.to_json(response) ) except: response_payload = None @@ -26203,10 +27274,10 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.set_automated_ga4_configuration_opt_out", + "Received response for google.analytics.admin_v1alpha.AnalyticsAdminServiceClient.submit_user_deletion", extra={ "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", - "rpcName": "SetAutomatedGa4ConfigurationOptOut", + "rpcName": "SubmitUserDeletion", "metadata": http_response["headers"], "httpResponse": http_response, }, @@ -29896,6 +30967,171 @@ def __call__( ) return resp + class _UpdateReportingDataAnnotation( + _BaseAnalyticsAdminServiceRestTransport._BaseUpdateReportingDataAnnotation, + AnalyticsAdminServiceRestStub, + ): + def __hash__(self): + return hash( + "AnalyticsAdminServiceRestTransport.UpdateReportingDataAnnotation" + ) + + @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: analytics_admin.UpdateReportingDataAnnotationRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> resources.ReportingDataAnnotation: + r"""Call the update reporting data + annotation method over HTTP. + + Args: + request (~.analytics_admin.UpdateReportingDataAnnotationRequest): + The request object. Request message for + UpdateReportingDataAnnotation 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: + ~.resources.ReportingDataAnnotation: + A Reporting Data Annotation is a + comment connected to certain dates for + reporting data. + + """ + + http_options = ( + _BaseAnalyticsAdminServiceRestTransport._BaseUpdateReportingDataAnnotation._get_http_options() + ) + + request, metadata = self._interceptor.pre_update_reporting_data_annotation( + request, metadata + ) + transcoded_request = _BaseAnalyticsAdminServiceRestTransport._BaseUpdateReportingDataAnnotation._get_transcoded_request( + http_options, request + ) + + body = _BaseAnalyticsAdminServiceRestTransport._BaseUpdateReportingDataAnnotation._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseAnalyticsAdminServiceRestTransport._BaseUpdateReportingDataAnnotation._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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.UpdateReportingDataAnnotation", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "UpdateReportingDataAnnotation", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = AnalyticsAdminServiceRestTransport._UpdateReportingDataAnnotation._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 = resources.ReportingDataAnnotation() + pb_resp = resources.ReportingDataAnnotation.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_update_reporting_data_annotation(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + ( + resp, + _, + ) = self._interceptor.post_update_reporting_data_annotation_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = resources.ReportingDataAnnotation.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.analytics.admin_v1alpha.AnalyticsAdminServiceClient.update_reporting_data_annotation", + extra={ + "serviceName": "google.analytics.admin.v1alpha.AnalyticsAdminService", + "rpcName": "UpdateReportingDataAnnotation", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + class _UpdateSearchAds360Link( _BaseAnalyticsAdminServiceRestTransport._BaseUpdateSearchAds360Link, AnalyticsAdminServiceRestStub, @@ -30688,6 +31924,17 @@ def create_property( # In C++ this would require a dynamic_cast return self._CreateProperty(self._session, self._host, self._interceptor) # type: ignore + @property + def create_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.CreateReportingDataAnnotationRequest], + resources.ReportingDataAnnotation, + ]: + # 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._CreateReportingDataAnnotation(self._session, self._host, self._interceptor) # type: ignore + @property def create_rollup_property( self, @@ -30901,6 +32148,16 @@ def delete_property( # In C++ this would require a dynamic_cast return self._DeleteProperty(self._session, self._host, self._interceptor) # type: ignore + @property + def delete_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.DeleteReportingDataAnnotationRequest], empty_pb2.Empty + ]: + # 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._DeleteReportingDataAnnotation(self._session, self._host, self._interceptor) # type: ignore + @property def delete_rollup_property_source_link( self, @@ -31207,6 +32464,17 @@ def get_property( # In C++ this would require a dynamic_cast return self._GetProperty(self._session, self._host, self._interceptor) # type: ignore + @property + def get_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.GetReportingDataAnnotationRequest], + resources.ReportingDataAnnotation, + ]: + # 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._GetReportingDataAnnotation(self._session, self._host, self._interceptor) # type: ignore + @property def get_rollup_property_source_link( self, @@ -31499,6 +32767,17 @@ def list_properties( # In C++ this would require a dynamic_cast return self._ListProperties(self._session, self._host, self._interceptor) # type: ignore + @property + def list_reporting_data_annotations( + self, + ) -> Callable[ + [analytics_admin.ListReportingDataAnnotationsRequest], + analytics_admin.ListReportingDataAnnotationsResponse, + ]: + # 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._ListReportingDataAnnotations(self._session, self._host, self._interceptor) # type: ignore + @property def list_rollup_property_source_links( self, @@ -31606,6 +32885,17 @@ def set_automated_ga4_configuration_opt_out( # In C++ this would require a dynamic_cast return self._SetAutomatedGa4ConfigurationOptOut(self._session, self._host, self._interceptor) # type: ignore + @property + def submit_user_deletion( + self, + ) -> Callable[ + [analytics_admin.SubmitUserDeletionRequest], + analytics_admin.SubmitUserDeletionResponse, + ]: + # 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._SubmitUserDeletion(self._session, self._host, self._interceptor) # type: ignore + @property def update_access_binding( self, @@ -31832,6 +33122,17 @@ def update_property( # In C++ this would require a dynamic_cast return self._UpdateProperty(self._session, self._host, self._interceptor) # type: ignore + @property + def update_reporting_data_annotation( + self, + ) -> Callable[ + [analytics_admin.UpdateReportingDataAnnotationRequest], + resources.ReportingDataAnnotation, + ]: + # 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._UpdateReportingDataAnnotation(self._session, self._host, self._interceptor) # type: ignore + @property def update_search_ads360_link( self, diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest_base.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest_base.py index e1e557144fe9..3ab9634c122b 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest_base.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/services/analytics_admin_service/transports/rest_base.py @@ -1905,6 +1905,65 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseCreateReportingDataAnnotation: + 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/{parent=properties/*}/reportingDataAnnotations", + "body": "reporting_data_annotation", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = analytics_admin.CreateReportingDataAnnotationRequest.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( + _BaseAnalyticsAdminServiceRestTransport._BaseCreateReportingDataAnnotation._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseCreateRollupProperty: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -3096,6 +3155,55 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseDeleteReportingDataAnnotation: + 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": "/v1alpha/{name=properties/*/reportingDataAnnotations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = analytics_admin.DeleteReportingDataAnnotationRequest.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( + _BaseAnalyticsAdminServiceRestTransport._BaseDeleteReportingDataAnnotation._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseDeleteRollupPropertySourceLink: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -4632,6 +4740,53 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseGetReportingDataAnnotation: + 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": "/v1alpha/{name=properties/*/reportingDataAnnotations/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = analytics_admin.GetReportingDataAnnotationRequest.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( + _BaseAnalyticsAdminServiceRestTransport._BaseGetReportingDataAnnotation._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseGetRollupPropertySourceLink: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -5882,6 +6037,53 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseListReportingDataAnnotations: + 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": "/v1alpha/{parent=properties/*}/reportingDataAnnotations", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = analytics_admin.ListReportingDataAnnotationsRequest.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( + _BaseAnalyticsAdminServiceRestTransport._BaseListReportingDataAnnotations._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseListRollupPropertySourceLinks: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -6393,6 +6595,63 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseSubmitUserDeletion: + 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/{name=properties/*}:submitUserDeletion", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = analytics_admin.SubmitUserDeletionRequest.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( + _BaseAnalyticsAdminServiceRestTransport._BaseSubmitUserDeletion._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseUpdateAccessBinding: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -7759,6 +8018,65 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseUpdateReportingDataAnnotation: + 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": "patch", + "uri": "/v1alpha/{reporting_data_annotation.name=properties/*/reportingDataAnnotations/*}", + "body": "reporting_data_annotation", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = analytics_admin.UpdateReportingDataAnnotationRequest.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( + _BaseAnalyticsAdminServiceRestTransport._BaseUpdateReportingDataAnnotation._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseUpdateSearchAds360Link: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/__init__.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/__init__.py index e76eea908a58..883caf1f5ff6 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/__init__.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/__init__.py @@ -72,6 +72,7 @@ CreateKeyEventRequest, CreateMeasurementProtocolSecretRequest, CreatePropertyRequest, + CreateReportingDataAnnotationRequest, CreateRollupPropertyRequest, CreateRollupPropertyResponse, CreateRollupPropertySourceLinkRequest, @@ -97,6 +98,7 @@ DeleteKeyEventRequest, DeleteMeasurementProtocolSecretRequest, DeletePropertyRequest, + DeleteReportingDataAnnotationRequest, DeleteRollupPropertySourceLinkRequest, DeleteSearchAds360LinkRequest, DeleteSKAdNetworkConversionValueSchemaRequest, @@ -131,6 +133,7 @@ GetKeyEventRequest, GetMeasurementProtocolSecretRequest, GetPropertyRequest, + GetReportingDataAnnotationRequest, GetRollupPropertySourceLinkRequest, GetSearchAds360LinkRequest, GetSKAdNetworkConversionValueSchemaRequest, @@ -181,6 +184,8 @@ ListMeasurementProtocolSecretsResponse, ListPropertiesRequest, ListPropertiesResponse, + ListReportingDataAnnotationsRequest, + ListReportingDataAnnotationsResponse, ListRollupPropertySourceLinksRequest, ListRollupPropertySourceLinksResponse, ListSearchAds360LinksRequest, @@ -200,6 +205,8 @@ SearchChangeHistoryEventsResponse, SetAutomatedGa4ConfigurationOptOutRequest, SetAutomatedGa4ConfigurationOptOutResponse, + SubmitUserDeletionRequest, + SubmitUserDeletionResponse, UpdateAccessBindingRequest, UpdateAccountRequest, UpdateAttributionSettingsRequest, @@ -223,6 +230,7 @@ UpdateKeyEventRequest, UpdateMeasurementProtocolSecretRequest, UpdatePropertyRequest, + UpdateReportingDataAnnotationRequest, UpdateSearchAds360LinkRequest, UpdateSKAdNetworkConversionValueSchemaRequest, UpdateSubpropertyEventFilterRequest, @@ -301,6 +309,7 @@ Property, PropertySummary, PropertyType, + ReportingDataAnnotation, RollupPropertySourceLink, SearchAds360Link, ServiceLevel, @@ -371,6 +380,7 @@ "CreateKeyEventRequest", "CreateMeasurementProtocolSecretRequest", "CreatePropertyRequest", + "CreateReportingDataAnnotationRequest", "CreateRollupPropertyRequest", "CreateRollupPropertyResponse", "CreateRollupPropertySourceLinkRequest", @@ -396,6 +406,7 @@ "DeleteKeyEventRequest", "DeleteMeasurementProtocolSecretRequest", "DeletePropertyRequest", + "DeleteReportingDataAnnotationRequest", "DeleteRollupPropertySourceLinkRequest", "DeleteSearchAds360LinkRequest", "DeleteSKAdNetworkConversionValueSchemaRequest", @@ -430,6 +441,7 @@ "GetKeyEventRequest", "GetMeasurementProtocolSecretRequest", "GetPropertyRequest", + "GetReportingDataAnnotationRequest", "GetRollupPropertySourceLinkRequest", "GetSearchAds360LinkRequest", "GetSKAdNetworkConversionValueSchemaRequest", @@ -480,6 +492,8 @@ "ListMeasurementProtocolSecretsResponse", "ListPropertiesRequest", "ListPropertiesResponse", + "ListReportingDataAnnotationsRequest", + "ListReportingDataAnnotationsResponse", "ListRollupPropertySourceLinksRequest", "ListRollupPropertySourceLinksResponse", "ListSearchAds360LinksRequest", @@ -499,6 +513,8 @@ "SearchChangeHistoryEventsResponse", "SetAutomatedGa4ConfigurationOptOutRequest", "SetAutomatedGa4ConfigurationOptOutResponse", + "SubmitUserDeletionRequest", + "SubmitUserDeletionResponse", "UpdateAccessBindingRequest", "UpdateAccountRequest", "UpdateAttributionSettingsRequest", @@ -522,6 +538,7 @@ "UpdateKeyEventRequest", "UpdateMeasurementProtocolSecretRequest", "UpdatePropertyRequest", + "UpdateReportingDataAnnotationRequest", "UpdateSearchAds360LinkRequest", "UpdateSKAdNetworkConversionValueSchemaRequest", "UpdateSubpropertyEventFilterRequest", @@ -580,6 +597,7 @@ "PostbackWindow", "Property", "PropertySummary", + "ReportingDataAnnotation", "RollupPropertySourceLink", "SearchAds360Link", "SKAdNetworkConversionValueSchema", diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/analytics_admin.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/analytics_admin.py index 312202211d74..d532be5ab6fe 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/analytics_admin.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/analytics_admin.py @@ -227,6 +227,14 @@ "ListSubpropertyEventFiltersResponse", "UpdateSubpropertyEventFilterRequest", "DeleteSubpropertyEventFilterRequest", + "CreateReportingDataAnnotationRequest", + "GetReportingDataAnnotationRequest", + "ListReportingDataAnnotationsRequest", + "ListReportingDataAnnotationsResponse", + "UpdateReportingDataAnnotationRequest", + "DeleteReportingDataAnnotationRequest", + "SubmitUserDeletionRequest", + "SubmitUserDeletionResponse", }, ) @@ -4994,4 +5002,288 @@ class DeleteSubpropertyEventFilterRequest(proto.Message): ) +class CreateReportingDataAnnotationRequest(proto.Message): + r"""Request message for CreateReportingDataAnnotation RPC. + + Attributes: + parent (str): + Required. The property for which to create a Reporting Data + Annotation. Format: properties/property_id Example: + properties/123 + reporting_data_annotation (google.analytics.admin_v1alpha.types.ReportingDataAnnotation): + Required. The Reporting Data Annotation to + create. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + reporting_data_annotation: resources.ReportingDataAnnotation = proto.Field( + proto.MESSAGE, + number=2, + message=resources.ReportingDataAnnotation, + ) + + +class GetReportingDataAnnotationRequest(proto.Message): + r"""Request message for GetReportingDataAnnotation RPC. + + Attributes: + name (str): + Required. Resource name of the Reporting Data Annotation to + lookup. Format: + properties/property_id/reportingDataAnnotations/reportingDataAnnotation + Example: properties/123/reportingDataAnnotations/456 + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class ListReportingDataAnnotationsRequest(proto.Message): + r"""Request message for ListReportingDataAnnotation RPC. + + Attributes: + parent (str): + Required. Resource name of the property. Format: + properties/property_id Example: properties/123 + filter (str): + Optional. Filter that restricts which reporting data + annotations under the parent property are listed. + + Supported fields are: + + - 'name' + - ``title`` + - ``description`` + - ``annotation_date`` + - ``annotation_date_range`` + - ``color`` + + Additionally, this API provides the following helper + functions: + + - annotation_duration() : the duration that this annotation + marks, + `durations `__. + expect a numeric representation of seconds followed by an + ``s`` suffix. + - is_annotation_in_range(start_date, end_date) : if the + annotation is in the range specified by the + ``start_date`` and ``end_date``. The dates are in + ISO-8601 format, for example ``2031-06-28``. + + Supported operations: + + - ``=`` : equals + - ``!=`` : not equals + - ``<`` : less than + - ``>`` : greater than + - ``<=`` : less than or equals + - ``>=`` : greater than or equals + - ``:`` : has operator + - ``=~`` : `regular + expression `__ + match + - ``!~`` : `regular + expression `__ + does not match + - ``NOT`` : Logical not + - ``AND`` : Logical and + - ``OR`` : Logical or + + Examples: + + 1. ``title="Holiday Sale"`` + 2. ``description=~"[Bb]ig [Gg]ame.*[Ss]ale"`` + 3. ``is_annotation_in_range("2025-12-25", "2026-01-16") = true`` + 4. ``annotation_duration() >= 172800s AND title:BOGO`` + page_size (int): + Optional. The maximum number of resources to + return. The service may return fewer than this + value, even if there are additional pages. If + unspecified, at most 50 resources will be + returned. The maximum value is 200; (higher + values will be coerced to the maximum) + page_token (str): + Optional. A page token, received from a previous + ``ListReportingDataAnnotations`` call. Provide this to + retrieve the subsequent page. When paginating, all other + parameters provided to ``ListReportingDataAnnotations`` must + match the call that provided the page token. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + filter: 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, + ) + + +class ListReportingDataAnnotationsResponse(proto.Message): + r"""Response message for ListReportingDataAnnotation RPC. + + Attributes: + reporting_data_annotations (MutableSequence[google.analytics.admin_v1alpha.types.ReportingDataAnnotation]): + List of Reporting Data Annotations. + 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 + + reporting_data_annotations: MutableSequence[ + resources.ReportingDataAnnotation + ] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=resources.ReportingDataAnnotation, + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class UpdateReportingDataAnnotationRequest(proto.Message): + r"""Request message for UpdateReportingDataAnnotation RPC. + + Attributes: + reporting_data_annotation (google.analytics.admin_v1alpha.types.ReportingDataAnnotation): + Required. The Reporting Data Annotation to + update. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Optional. The list of fields to update. Field names must be + in snake case (for example, "field_to_update"). Omitted + fields will not be updated. To replace the entire entity, + use one path with the string "*" to match all fields. + """ + + reporting_data_annotation: resources.ReportingDataAnnotation = proto.Field( + proto.MESSAGE, + number=1, + message=resources.ReportingDataAnnotation, + ) + update_mask: field_mask_pb2.FieldMask = proto.Field( + proto.MESSAGE, + number=2, + message=field_mask_pb2.FieldMask, + ) + + +class DeleteReportingDataAnnotationRequest(proto.Message): + r"""Request message for DeleteReportingDataAnnotation RPC. + + Attributes: + name (str): + Required. Resource name of the Reporting Data Annotation to + delete. Format: + properties/property_id/reportingDataAnnotations/reporting_data_annotation + Example: properties/123/reportingDataAnnotations/456 + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class SubmitUserDeletionRequest(proto.Message): + r"""Request message for SubmitUserDeletion RPC. + + 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: + user_id (str): + Google Analytics `user + ID `__. + + This field is a member of `oneof`_ ``user``. + client_id (str): + Google Analytics `client + ID `__. + + This field is a member of `oneof`_ ``user``. + app_instance_id (str): + Firebase `application instance + ID `__. + + This field is a member of `oneof`_ ``user``. + user_provided_data (str): + The un-hashed, unencrypted, `user-provided + data `__. + + This field is a member of `oneof`_ ``user``. + name (str): + Required. The name of the property to submit + user deletion for. + """ + + user_id: str = proto.Field( + proto.STRING, + number=2, + oneof="user", + ) + client_id: str = proto.Field( + proto.STRING, + number=3, + oneof="user", + ) + app_instance_id: str = proto.Field( + proto.STRING, + number=4, + oneof="user", + ) + user_provided_data: str = proto.Field( + proto.STRING, + number=5, + oneof="user", + ) + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class SubmitUserDeletionResponse(proto.Message): + r"""Response message for SubmitUserDeletion RPC. + + Attributes: + deletion_request_time (google.protobuf.timestamp_pb2.Timestamp): + Marks the moment for which all visitor data + before this point should be deleted. This is set + to the time at which the deletion request was + received. + """ + + deletion_request_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=1, + message=timestamp_pb2.Timestamp, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/resources.py b/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/resources.py index 6effcac02777..047cf4e205a8 100644 --- a/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/resources.py +++ b/packages/google-analytics-admin/google/analytics/admin_v1alpha/types/resources.py @@ -19,6 +19,7 @@ from google.protobuf import timestamp_pb2 # type: ignore from google.protobuf import wrappers_pb2 # type: ignore +from google.type import date_pb2 # type: ignore import proto # type: ignore from google.analytics.admin_v1alpha.types import channel_group as gaa_channel_group @@ -77,6 +78,7 @@ "DataRedactionSettings", "AdSenseLink", "RollupPropertySourceLink", + "ReportingDataAnnotation", }, ) @@ -283,10 +285,12 @@ class ChangeHistoryResourceType(proto.Enum): Audience resource EVENT_CREATE_RULE (29): EventCreateRule resource + KEY_EVENT (30): + KeyEvent resource CALCULATED_METRIC (31): CalculatedMetric resource - KEY_EVENT (32): - KeyEvent resource + REPORTING_DATA_ANNOTATION (32): + ReportingDataAnnotation resource """ CHANGE_HISTORY_RESOURCE_TYPE_UNSPECIFIED = 0 ACCOUNT = 1 @@ -313,8 +317,9 @@ class ChangeHistoryResourceType(proto.Enum): ADSENSE_LINK = 27 AUDIENCE = 28 EVENT_CREATE_RULE = 29 + KEY_EVENT = 30 CALCULATED_METRIC = 31 - KEY_EVENT = 32 + REPORTING_DATA_ANNOTATION = 32 class GoogleSignalsState(proto.Enum): @@ -976,24 +981,49 @@ class DataSharingSettings(proto.Message): Format: accounts/{account}/dataSharingSettings Example: "accounts/1000/dataSharingSettings". sharing_with_google_support_enabled (bool): - Allows Google support to access the data in - order to help troubleshoot issues. + Allows Google technical support + representatives access to your Google Analytics + data and account when necessary to provide + service and find solutions to technical issues. + + This field maps to the "Technical support" field + in the Google Analytics Admin UI. sharing_with_google_assigned_sales_enabled (bool): - Allows Google sales teams that are assigned - to the customer to access the data in order to - suggest configuration changes to improve - results. Sales team restrictions still apply - when enabled. + Allows Google access to your Google Analytics + account data, including account usage and + configuration data, product spending, and users + associated with your Google Analytics account, + so that Google can help you make the most of + Google products, providing you with insights, + offers, recommendations, and optimization tips + across Google Analytics and other Google + products for business. + + This field maps to the "Recommendations for your + business" field in the Google Analytics Admin + UI. sharing_with_google_any_sales_enabled (bool): - Allows any of Google sales to access the data - in order to suggest configuration changes to - improve results. + Deprecated. This field is no longer used and + always returns false. sharing_with_google_products_enabled (bool): Allows Google to use the data to improve other Google products or services. + This fields maps to the "Google products & + services" field in the Google Analytics Admin + UI. sharing_with_others_enabled (bool): - Allows Google to share the data anonymously - in aggregate form with others. + Enable features like predictions, modeled + data, and benchmarking that can provide you with + richer business insights when you contribute + aggregated measurement data. The data you share + (including information about the property from + which it is shared) is aggregated and + de-identified before being used to generate + business insights. + + This field maps to the "Modeling contributions & + business insights" field in the Google Analytics + Admin UI. """ name: str = proto.Field( @@ -1590,15 +1620,20 @@ class ChangeHistoryResource(proto.Message): A snapshot of an EventCreateRule resource in change history. + This field is a member of `oneof`_ ``resource``. + key_event (google.analytics.admin_v1alpha.types.KeyEvent): + A snapshot of a KeyEvent resource in change + history. + This field is a member of `oneof`_ ``resource``. calculated_metric (google.analytics.admin_v1alpha.types.CalculatedMetric): A snapshot of a CalculatedMetric resource in change history. This field is a member of `oneof`_ ``resource``. - key_event (google.analytics.admin_v1alpha.types.KeyEvent): - A snapshot of a KeyEvent resource in change - history. + reporting_data_annotation (google.analytics.admin_v1alpha.types.ReportingDataAnnotation): + A snapshot of a ReportingDataAnnotation + resource in change history. This field is a member of `oneof`_ ``resource``. """ @@ -1751,17 +1786,23 @@ class ChangeHistoryResource(proto.Message): oneof="resource", message=event_create_and_edit.EventCreateRule, ) + key_event: "KeyEvent" = proto.Field( + proto.MESSAGE, + number=30, + oneof="resource", + message="KeyEvent", + ) calculated_metric: "CalculatedMetric" = proto.Field( proto.MESSAGE, number=31, oneof="resource", message="CalculatedMetric", ) - key_event: "KeyEvent" = proto.Field( + reporting_data_annotation: "ReportingDataAnnotation" = proto.Field( proto.MESSAGE, number=32, oneof="resource", - message="KeyEvent", + message="ReportingDataAnnotation", ) resource: str = proto.Field( @@ -3286,4 +3327,144 @@ class RollupPropertySourceLink(proto.Message): ) +class ReportingDataAnnotation(proto.Message): + r"""A Reporting Data Annotation is a comment connected to certain + dates for reporting data. + + 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: + annotation_date (google.type.date_pb2.Date): + If set, the Reporting Data Annotation is for + a specific date represented by this field. The + date must be a valid date with year, month and + day set. The date may be in the past, present, + or future. + + This field is a member of `oneof`_ ``target``. + annotation_date_range (google.analytics.admin_v1alpha.types.ReportingDataAnnotation.DateRange): + If set, the Reporting Data Annotation is for + a range of dates represented by this field. + + This field is a member of `oneof`_ ``target``. + name (str): + Required. Identifier. Resource name of this Reporting Data + Annotation. Format: + 'properties/{property_id}/reportingDataAnnotations/{reporting_data_annotation}' + Format: 'properties/123/reportingDataAnnotations/456' + title (str): + Required. Human-readable title for this + Reporting Data Annotation. + description (str): + Optional. Description for this Reporting Data + Annotation. + color (google.analytics.admin_v1alpha.types.ReportingDataAnnotation.Color): + Required. The color used for display of this + Reporting Data Annotation. + system_generated (bool): + Output only. If true, this annotation was + generated by the Google Analytics system. + System-generated annotations cannot be updated + or deleted. + """ + + class Color(proto.Enum): + r"""Colors that may be used for this Reporting Data Annotation + + Values: + COLOR_UNSPECIFIED (0): + Color unknown or not specified. + PURPLE (1): + Purple color. + BROWN (2): + Brown color. + BLUE (3): + Blue color. + GREEN (4): + Green color. + RED (5): + Red color. + CYAN (6): + Cyan color. + ORANGE (7): + Orange color. (Only used for system-generated + annotations) + """ + COLOR_UNSPECIFIED = 0 + PURPLE = 1 + BROWN = 2 + BLUE = 3 + GREEN = 4 + RED = 5 + CYAN = 6 + ORANGE = 7 + + class DateRange(proto.Message): + r"""Represents a Reporting Data Annotation's date range, both + start and end dates are inclusive. Time zones are based on the + parent property. + + Attributes: + start_date (google.type.date_pb2.Date): + Required. The start date for this range. Must + be a valid date with year, month, and day set. + The date may be in the past, present, or future. + end_date (google.type.date_pb2.Date): + Required. The end date for this range. Must + be a valid date with year, month, and day set. + This date must be greater than or equal to the + start date. + """ + + start_date: date_pb2.Date = proto.Field( + proto.MESSAGE, + number=1, + message=date_pb2.Date, + ) + end_date: date_pb2.Date = proto.Field( + proto.MESSAGE, + number=2, + message=date_pb2.Date, + ) + + annotation_date: date_pb2.Date = proto.Field( + proto.MESSAGE, + number=4, + oneof="target", + message=date_pb2.Date, + ) + annotation_date_range: DateRange = proto.Field( + proto.MESSAGE, + number=5, + oneof="target", + message=DateRange, + ) + name: str = proto.Field( + proto.STRING, + number=1, + ) + title: str = proto.Field( + proto.STRING, + number=2, + ) + description: str = proto.Field( + proto.STRING, + number=3, + ) + color: Color = proto.Field( + proto.ENUM, + number=6, + enum=Color, + ) + system_generated: bool = proto.Field( + proto.BOOL, + number=7, + ) + + __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/packages/google-analytics-admin/scripts/fixup_admin_v1alpha_keywords.py b/packages/google-analytics-admin/scripts/fixup_admin_v1alpha_keywords.py index b089c29bb7cb..fac87260d48e 100644 --- a/packages/google-analytics-admin/scripts/fixup_admin_v1alpha_keywords.py +++ b/packages/google-analytics-admin/scripts/fixup_admin_v1alpha_keywords.py @@ -70,6 +70,7 @@ class adminCallTransformer(cst.CSTTransformer): 'create_key_event': ('key_event', 'parent', ), 'create_measurement_protocol_secret': ('parent', 'measurement_protocol_secret', ), 'create_property': ('property', ), + 'create_reporting_data_annotation': ('parent', 'reporting_data_annotation', ), 'create_rollup_property': ('rollup_property', 'source_properties', ), 'create_rollup_property_source_link': ('parent', 'rollup_property_source_link', ), 'create_search_ads360_link': ('parent', 'search_ads_360_link', ), @@ -94,6 +95,7 @@ class adminCallTransformer(cst.CSTTransformer): 'delete_key_event': ('name', ), 'delete_measurement_protocol_secret': ('name', ), 'delete_property': ('name', ), + 'delete_reporting_data_annotation': ('name', ), 'delete_rollup_property_source_link': ('name', ), 'delete_search_ads360_link': ('name', ), 'delete_sk_ad_network_conversion_value_schema': ('name', ), @@ -126,6 +128,7 @@ class adminCallTransformer(cst.CSTTransformer): 'get_key_event': ('name', ), 'get_measurement_protocol_secret': ('name', ), 'get_property': ('name', ), + 'get_reporting_data_annotation': ('name', ), 'get_rollup_property_source_link': ('name', ), 'get_search_ads360_link': ('name', ), 'get_sk_ad_network_conversion_value_schema': ('name', ), @@ -153,6 +156,7 @@ class adminCallTransformer(cst.CSTTransformer): 'list_key_events': ('parent', 'page_size', 'page_token', ), 'list_measurement_protocol_secrets': ('parent', 'page_size', 'page_token', ), 'list_properties': ('filter', 'page_size', 'page_token', 'show_deleted', ), + 'list_reporting_data_annotations': ('parent', 'filter', 'page_size', 'page_token', ), 'list_rollup_property_source_links': ('parent', 'page_size', 'page_token', ), 'list_search_ads360_links': ('parent', 'page_size', 'page_token', ), 'list_sk_ad_network_conversion_value_schemas': ('parent', 'page_size', 'page_token', ), @@ -163,6 +167,7 @@ class adminCallTransformer(cst.CSTTransformer): 'run_access_report': ('entity', 'dimensions', 'metrics', 'date_ranges', 'dimension_filter', 'metric_filter', 'offset', 'limit', 'time_zone', 'order_bys', 'return_entity_quota', 'include_all_users', 'expand_groups', ), 'search_change_history_events': ('account', 'property', 'resource_type', 'action', 'actor_email', 'earliest_change_time', 'latest_change_time', 'page_size', 'page_token', ), 'set_automated_ga4_configuration_opt_out': ('property', 'opt_out', ), + 'submit_user_deletion': ('name', 'user_id', 'client_id', 'app_instance_id', 'user_provided_data', ), 'update_access_binding': ('access_binding', ), 'update_account': ('account', 'update_mask', ), 'update_attribution_settings': ('attribution_settings', 'update_mask', ), @@ -186,6 +191,7 @@ class adminCallTransformer(cst.CSTTransformer): 'update_key_event': ('key_event', 'update_mask', ), 'update_measurement_protocol_secret': ('measurement_protocol_secret', 'update_mask', ), 'update_property': ('property', 'update_mask', ), + 'update_reporting_data_annotation': ('reporting_data_annotation', 'update_mask', ), 'update_search_ads360_link': ('update_mask', 'search_ads_360_link', ), 'update_sk_ad_network_conversion_value_schema': ('skadnetwork_conversion_value_schema', 'update_mask', ), 'update_subproperty_event_filter': ('subproperty_event_filter', 'update_mask', ), diff --git a/packages/google-analytics-admin/tests/unit/gapic/admin_v1alpha/test_analytics_admin_service.py b/packages/google-analytics-admin/tests/unit/gapic/admin_v1alpha/test_analytics_admin_service.py index 67c38493bb6d..950504829bc7 100644 --- a/packages/google-analytics-admin/tests/unit/gapic/admin_v1alpha/test_analytics_admin_service.py +++ b/packages/google-analytics-admin/tests/unit/gapic/admin_v1alpha/test_analytics_admin_service.py @@ -55,6 +55,7 @@ from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from google.protobuf import wrappers_pb2 # type: ignore +from google.type import date_pb2 # type: ignore from google.analytics.admin_v1alpha.services.analytics_admin_service import ( AnalyticsAdminServiceAsyncClient, @@ -56516,13 +56517,89 @@ async def test_delete_subproperty_event_filter_flattened_error_async(): ) -def test_get_account_rest_use_cached_wrapped_rpc(): +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.CreateReportingDataAnnotationRequest, + dict, + ], +) +def test_create_reporting_data_annotation(request_type, transport: str = "grpc"): + client = AnalyticsAdminServiceClient( + 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_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + response = client.create_reporting_data_annotation(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = analytics_admin.CreateReportingDataAnnotationRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.ReportingDataAnnotation) + assert response.name == "name_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True + + +def test_create_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + 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 = analytics_admin.CreateReportingDataAnnotationRequest( + parent="parent_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.create_reporting_data_annotation(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == analytics_admin.CreateReportingDataAnnotationRequest( + parent="parent_value", + ) + + +def test_create_reporting_data_annotation_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -56530,274 +56607,380 @@ def test_get_account_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_account in client._transport._wrapped_methods + assert ( + client._transport.create_reporting_data_annotation + 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_account] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.create_reporting_data_annotation + ] = mock_rpc request = {} - client.get_account(request) + client.create_reporting_data_annotation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_account(request) + client.create_reporting_data_annotation(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_account_rest_required_fields( - request_type=analytics_admin.GetAccountRequest, +@pytest.mark.asyncio +async def test_create_reporting_data_annotation_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.AnalyticsAdminServiceRestTransport + # 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 = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - 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) - ) + # 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.create_reporting_data_annotation + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_account._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.create_reporting_data_annotation + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.create_reporting_data_annotation(request) - jsonified_request["name"] = "name_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_account._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + await client.create_reporting_data_annotation(request) - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_create_reporting_data_annotation_async( + transport: str = "grpc_asyncio", + request_type=analytics_admin.CreateReportingDataAnnotationRequest, +): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = resources.Account() - # 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.create_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + ) + response = await client.create_reporting_data_annotation(request) - # Convert return value to protobuf type - return_value = resources.Account.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 = analytics_admin.CreateReportingDataAnnotationRequest() + 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, resources.ReportingDataAnnotation) + assert response.name == "name_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True - response = client.get_account(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_create_reporting_data_annotation_async_from_dict(): + await test_create_reporting_data_annotation_async(request_type=dict) -def test_get_account_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_create_reporting_data_annotation_field_headers(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.get_account._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + # 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 = analytics_admin.CreateReportingDataAnnotationRequest() + + request.parent = "parent_value" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + call.return_value = resources.ReportingDataAnnotation() + client.create_reporting_data_annotation(request) -def test_get_account_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + # 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_reporting_data_annotation_field_headers_async(): + client = AnalyticsAdminServiceAsyncClient( + 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 = resources.Account() + # 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 = analytics_admin.CreateReportingDataAnnotationRequest() - # get arguments that satisfy an http rule for this method - sample_request = {"name": "accounts/sample1"} + request.parent = "parent_value" - # get truthy value for each flattened field - mock_args = dict( - name="name_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation() ) - mock_args.update(sample_request) + await client.create_reporting_data_annotation(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.Account.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"} + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request - client.get_account(**mock_args) + # 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_reporting_data_annotation_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.create_reporting_data_annotation( + parent="parent_value", + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + ) # 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=accounts/*}" % client.transport._host, args[1] + 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].reporting_data_annotation + mock_val = resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) ) + assert arg == mock_val -def test_get_account_rest_flattened_error(transport: str = "rest"): +def test_create_reporting_data_annotation_flattened_error(): client = AnalyticsAdminServiceClient( 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_account( - analytics_admin.GetAccountRequest(), - name="name_value", + client.create_reporting_data_annotation( + analytics_admin.CreateReportingDataAnnotationRequest(), + parent="parent_value", + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), ) -def test_list_accounts_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +@pytest.mark.asyncio +async def test_create_reporting_data_annotation_flattened_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - # Ensure method has been cached - assert client._transport.list_accounts in client._transport._wrapped_methods + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation() - # 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. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.create_reporting_data_annotation( + parent="parent_value", + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), ) - client._transport._wrapped_methods[client._transport.list_accounts] = mock_rpc - request = {} - client.list_accounts(request) + # 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].reporting_data_annotation + mock_val = resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ) + assert arg == mock_val - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - client.list_accounts(request) +@pytest.mark.asyncio +async def test_create_reporting_data_annotation_flattened_error_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.create_reporting_data_annotation( + analytics_admin.CreateReportingDataAnnotationRequest(), + parent="parent_value", + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + ) -def test_list_accounts_rest_pager(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetReportingDataAnnotationRequest, + dict, + ], +) +def test_get_reporting_data_annotation(request_type, transport: str = "grpc"): client = AnalyticsAdminServiceClient( 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 = ( - analytics_admin.ListAccountsResponse( - accounts=[ - resources.Account(), - resources.Account(), - resources.Account(), - ], - next_page_token="abc", - ), - analytics_admin.ListAccountsResponse( - accounts=[], - next_page_token="def", - ), - analytics_admin.ListAccountsResponse( - accounts=[ - resources.Account(), - ], - next_page_token="ghi", - ), - analytics_admin.ListAccountsResponse( - accounts=[ - resources.Account(), - resources.Account(), - ], - ), - ) - # Two responses for two calls - response = response + response + # 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() - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListAccountsResponse.to_json(x) for x in response + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, ) - 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 + response = client.get_reporting_data_annotation(request) - sample_request = {} + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = analytics_admin.GetReportingDataAnnotationRequest() + assert args[0] == request - pager = client.list_accounts(request=sample_request) + # Establish that the response is the type that we expect. + assert isinstance(response, resources.ReportingDataAnnotation) + assert response.name == "name_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.Account) for i in results) - pages = list(client.list_accounts(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +def test_get_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + 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 = analytics_admin.GetReportingDataAnnotationRequest( + name="name_value", + ) -def test_delete_account_rest_use_cached_wrapped_rpc(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_reporting_data_annotation(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == analytics_admin.GetReportingDataAnnotationRequest( + name="name_value", + ) + + +def test_get_reporting_data_annotation_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -56805,354 +56988,354 @@ def test_delete_account_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_account in client._transport._wrapped_methods + assert ( + client._transport.get_reporting_data_annotation + 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_account] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.get_reporting_data_annotation + ] = mock_rpc request = {} - client.delete_account(request) + client.get_reporting_data_annotation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_account(request) + client.get_reporting_data_annotation(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_account_rest_required_fields( - request_type=analytics_admin.DeleteAccountRequest, +@pytest.mark.asyncio +async def test_get_reporting_data_annotation_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.AnalyticsAdminServiceRestTransport + # 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 = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - 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) - ) + # 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.get_reporting_data_annotation + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_account._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.get_reporting_data_annotation + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.get_reporting_data_annotation(request) - jsonified_request["name"] = "name_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_account._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + await client.get_reporting_data_annotation(request) - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_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 = AnalyticsAdminServiceClient( - 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 = "" +@pytest.mark.asyncio +async def test_get_reporting_data_annotation_async( + transport: str = "grpc_asyncio", + request_type=analytics_admin.GetReportingDataAnnotationRequest, +): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - 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"} + # 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 = client.delete_account(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + ) + response = await client.get_reporting_data_annotation(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = analytics_admin.GetReportingDataAnnotationRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, resources.ReportingDataAnnotation) + assert response.name == "name_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True -def test_delete_account_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.delete_account._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) +@pytest.mark.asyncio +async def test_get_reporting_data_annotation_async_from_dict(): + await test_get_reporting_data_annotation_async(request_type=dict) -def test_delete_account_rest_flattened(): +def test_get_reporting_data_annotation_field_headers(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "accounts/sample1"} + # 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 = analytics_admin.GetReportingDataAnnotationRequest() - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) + request.name = "name_value" - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + call.return_value = resources.ReportingDataAnnotation() + client.get_reporting_data_annotation(request) - client.delete_account(**mock_args) + # 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 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=accounts/*}" % client.transport._host, args[1] - ) + # 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_account_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, +@pytest.mark.asyncio +async def test_get_reporting_data_annotation_field_headers_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.delete_account( - analytics_admin.DeleteAccountRequest(), - name="name_value", - ) - - -def test_update_account_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() + # 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 = analytics_admin.GetReportingDataAnnotationRequest() - # Ensure method has been cached - assert client._transport.update_account in client._transport._wrapped_methods + request.name = "name_value" - # 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. + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation() ) - client._transport._wrapped_methods[client._transport.update_account] = mock_rpc - - request = {} - client.update_account(request) + await client.get_reporting_data_annotation(request) # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.update_account(request) - - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + assert 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_update_account_rest_required_fields( - request_type=analytics_admin.UpdateAccountRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - 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) +def test_get_reporting_data_annotation_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_account._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - - # verify required fields with default values are now present + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_reporting_data_annotation( + name="name_value", + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_account._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) + # 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 - # verify required fields with non-default values are left alone +def test_get_reporting_data_annotation_flattened_error(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = resources.Account() - # 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 + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_reporting_data_annotation( + analytics_admin.GetReportingDataAnnotationRequest(), + name="name_value", + ) - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.Account.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_get_reporting_data_annotation_flattened_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - 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"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation() - response = client.update_account(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_reporting_data_annotation( + name="name_value", + ) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # 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 -def test_update_account_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_get_reporting_data_annotation_flattened_error_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.update_account._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "account", - "updateMask", - ) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_reporting_data_annotation( + analytics_admin.GetReportingDataAnnotationRequest(), + name="name_value", ) - ) -def test_update_account_rest_flattened(): +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.ListReportingDataAnnotationsRequest, + dict, + ], +) +def test_list_reporting_data_annotations(request_type, transport: str = "grpc"): client = AnalyticsAdminServiceClient( 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 = resources.Account() - - # get arguments that satisfy an http rule for this method - sample_request = {"account": {"name": "accounts/sample1"}} + # 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() - # get truthy value for each flattened field - mock_args = dict( - account=resources.Account(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = analytics_admin.ListReportingDataAnnotationsResponse( + next_page_token="next_page_token_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.Account.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_reporting_data_annotations(request) - client.update_account(**mock_args) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = analytics_admin.ListReportingDataAnnotationsRequest() + assert args[0] == 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/v1alpha/{account.name=accounts/*}" % client.transport._host, args[1] - ) + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListReportingDataAnnotationsPager) + assert response.next_page_token == "next_page_token_value" -def test_update_account_rest_flattened_error(transport: str = "rest"): +def test_list_reporting_data_annotations_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="grpc", ) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.update_account( - analytics_admin.UpdateAccountRequest(), - account=resources.Account(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + # 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 = analytics_admin.ListReportingDataAnnotationsRequest( + parent="parent_value", + filter="filter_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.list_reporting_data_annotations), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_reporting_data_annotations(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == analytics_admin.ListReportingDataAnnotationsRequest( + parent="parent_value", + filter="filter_value", + page_token="page_token_value", ) -def test_provision_account_ticket_rest_use_cached_wrapped_rpc(): +def test_list_reporting_data_annotations_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -57161,7 +57344,7 @@ def test_provision_account_ticket_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.provision_account_ticket + client._transport.list_reporting_data_annotations in client._transport._wrapped_methods ) @@ -57171,29 +57354,31 @@ def test_provision_account_ticket_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.provision_account_ticket + client._transport.list_reporting_data_annotations ] = mock_rpc - request = {} - client.provision_account_ticket(request) + client.list_reporting_data_annotations(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.provision_account_ticket(request) + client.list_reporting_data_annotations(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_account_summaries_rest_use_cached_wrapped_rpc(): +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_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.wrap_method") as wrapper_fn: - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) # Should wrap all calls on client creation @@ -57202,489 +57387,506 @@ def test_list_account_summaries_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_account_summaries - in client._transport._wrapped_methods + client._client._transport.list_reporting_data_annotations + in client._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_account_summaries + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.list_reporting_data_annotations ] = mock_rpc request = {} - client.list_account_summaries(request) + await client.list_reporting_data_annotations(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_account_summaries(request) + await client.list_reporting_data_annotations(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_account_summaries_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_async( + transport: str = "grpc_asyncio", + request_type=analytics_admin.ListReportingDataAnnotationsRequest, +): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), 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 = ( - analytics_admin.ListAccountSummariesResponse( - account_summaries=[ - resources.AccountSummary(), - resources.AccountSummary(), - resources.AccountSummary(), - ], - next_page_token="abc", - ), - analytics_admin.ListAccountSummariesResponse( - account_summaries=[], - next_page_token="def", - ), - analytics_admin.ListAccountSummariesResponse( - account_summaries=[ - resources.AccountSummary(), - ], - next_page_token="ghi", - ), - analytics_admin.ListAccountSummariesResponse( - account_summaries=[ - resources.AccountSummary(), - resources.AccountSummary(), - ], - ), - ) - # Two responses for two calls - response = response + response + # 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() - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListAccountSummariesResponse.to_json(x) for x in response + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListReportingDataAnnotationsResponse( + next_page_token="next_page_token_value", + ) ) - 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 = {} + response = await client.list_reporting_data_annotations(request) - pager = client.list_account_summaries(request=sample_request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = analytics_admin.ListReportingDataAnnotationsRequest() + assert args[0] == request - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.AccountSummary) for i in results) + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListReportingDataAnnotationsAsyncPager) + assert response.next_page_token == "next_page_token_value" - pages = list(client.list_account_summaries(request=sample_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_reporting_data_annotations_async_from_dict(): + await test_list_reporting_data_annotations_async(request_type=dict) -def test_get_property_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +def test_list_reporting_data_annotations_field_headers(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) - # Ensure method has been cached - assert client._transport.get_property in client._transport._wrapped_methods + # 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 = analytics_admin.ListReportingDataAnnotationsRequest() - # 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_property] = mock_rpc + request.parent = "parent_value" - request = {} - client.get_property(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + call.return_value = analytics_admin.ListReportingDataAnnotationsResponse() + client.list_reporting_data_annotations(request) # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.get_property(request) + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == 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_property_rest_required_fields( - request_type=analytics_admin.GetPropertyRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - - 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_property._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_property._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_field_headers_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = resources.Property() - # 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.Property.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_property(request) + # 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 = analytics_admin.ListReportingDataAnnotationsRequest() - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + request.parent = "parent_value" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListReportingDataAnnotationsResponse() + ) + await client.list_reporting_data_annotations(request) -def test_get_property_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request - unset_fields = transport.get_property._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + # 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_get_property_rest_flattened(): +def test_list_reporting_data_annotations_flattened(): client = AnalyticsAdminServiceClient( 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.Property() - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = analytics_admin.ListReportingDataAnnotationsResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_reporting_data_annotations( + 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 = resources.Property.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_property(**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=properties/*}" % client.transport._host, args[1] - ) + 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_get_property_rest_flattened_error(transport: str = "rest"): +def test_list_reporting_data_annotations_flattened_error(): client = AnalyticsAdminServiceClient( 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_property( - analytics_admin.GetPropertyRequest(), - name="name_value", + client.list_reporting_data_annotations( + analytics_admin.ListReportingDataAnnotationsRequest(), + parent="parent_value", ) -def test_list_properties_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_flattened_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - # Ensure method has been cached - assert client._transport.list_properties in client._transport._wrapped_methods + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = analytics_admin.ListReportingDataAnnotationsResponse() - # 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. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListReportingDataAnnotationsResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_reporting_data_annotations( + parent="parent_value", ) - client._transport._wrapped_methods[client._transport.list_properties] = mock_rpc - - request = {} - client.list_properties(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.list_properties(request) - - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + # 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 -def test_list_properties_rest_required_fields( - request_type=analytics_admin.ListPropertiesRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - request_init = {} - request_init["filter"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_flattened_error_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - # verify fields with default values are dropped - assert "filter" not in jsonified_request - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_properties._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - - # verify required fields with default values are now present - assert "filter" in jsonified_request - assert jsonified_request["filter"] == request_init["filter"] - - jsonified_request["filter"] = "filter_value" - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_properties._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "filter", - "page_size", - "page_token", - "show_deleted", + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.list_reporting_data_annotations( + analytics_admin.ListReportingDataAnnotationsRequest(), + parent="parent_value", ) - ) - jsonified_request.update(unset_fields) - # verify required fields with non-default values are left alone - assert "filter" in jsonified_request - assert jsonified_request["filter"] == "filter_value" +def test_list_reporting_data_annotations_pager(transport_name: str = "grpc"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport_name, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListPropertiesResponse() - # 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 + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + next_page_token="abc", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[], + next_page_token="def", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + ], + next_page_token="ghi", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + ), + RuntimeError, + ) - response_value = Response() - response_value.status_code = 200 + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_reporting_data_annotations( + request={}, retry=retry, timeout=timeout + ) - # Convert return value to protobuf type - return_value = analytics_admin.ListPropertiesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout - 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"} + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.ReportingDataAnnotation) for i in results) - response = client.list_properties(request) - expected_params = [ - ( - "filter", - "", - ), - ("$alt", "json;enum-encoding=int"), - ] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params +def test_list_reporting_data_annotations_pages(transport_name: str = "grpc"): + client = AnalyticsAdminServiceClient( + 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_reporting_data_annotations), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + next_page_token="abc", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[], + next_page_token="def", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + ], + next_page_token="ghi", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + ), + RuntimeError, + ) + pages = list(client.list_reporting_data_annotations(request={}).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_list_properties_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_async_pager(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.list_properties._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "pageSize", - "pageToken", - "showDeleted", - ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + next_page_token="abc", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[], + next_page_token="def", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + ], + next_page_token="ghi", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + ), + RuntimeError, ) - & set(("filter",)) - ) + async_pager = await client.list_reporting_data_annotations( + 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.ReportingDataAnnotation) for i in responses) -def test_list_properties_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + +@pytest.mark.asyncio +async def test_list_reporting_data_annotations_async_pages(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - # 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 = ( - analytics_admin.ListPropertiesResponse( - properties=[ - resources.Property(), - resources.Property(), - resources.Property(), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), ], next_page_token="abc", ), - analytics_admin.ListPropertiesResponse( - properties=[], + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[], next_page_token="def", ), - analytics_admin.ListPropertiesResponse( - properties=[ - resources.Property(), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), ], next_page_token="ghi", ), - analytics_admin.ListPropertiesResponse( - properties=[ - resources.Property(), - resources.Property(), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), ], ), + RuntimeError, ) - # Two responses for two calls - response = response + response + 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_reporting_data_annotations(request={}) + ).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListPropertiesResponse.to_json(x) for x in response + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.UpdateReportingDataAnnotationRequest, + dict, + ], +) +def test_update_reporting_data_annotation(request_type, transport: str = "grpc"): + client = AnalyticsAdminServiceClient( + 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_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, ) - 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 + response = client.update_reporting_data_annotation(request) - sample_request = {} + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = analytics_admin.UpdateReportingDataAnnotationRequest() + assert args[0] == request - pager = client.list_properties(request=sample_request) + # Establish that the response is the type that we expect. + assert isinstance(response, resources.ReportingDataAnnotation) + assert response.name == "name_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.Property) for i in results) - pages = list(client.list_properties(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +def test_update_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + 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 = analytics_admin.UpdateReportingDataAnnotationRequest() -def test_create_property_rest_use_cached_wrapped_rpc(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.update_reporting_data_annotation(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == analytics_admin.UpdateReportingDataAnnotationRequest() + + +def test_update_reporting_data_annotation_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -57692,347 +57894,369 @@ def test_create_property_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_property in client._transport._wrapped_methods + assert ( + client._transport.update_reporting_data_annotation + 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_property] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.update_reporting_data_annotation + ] = mock_rpc request = {} - client.create_property(request) + client.update_reporting_data_annotation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_property(request) + client.update_reporting_data_annotation(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_property_rest_required_fields( - request_type=analytics_admin.CreatePropertyRequest, +@pytest.mark.asyncio +async def test_update_reporting_data_annotation_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.AnalyticsAdminServiceRestTransport - - 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) - ) + # 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 = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - # verify fields with default values are dropped + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_property._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Ensure method has been cached + assert ( + client._client._transport.update_reporting_data_annotation + in client._client._transport._wrapped_methods + ) - # verify required fields with default values are now present + # 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_reporting_data_annotation + ] = mock_rpc - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_property._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + request = {} + await client.update_reporting_data_annotation(request) - # verify required fields with non-default values are left alone + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + await client.update_reporting_data_annotation(request) - # Designate an appropriate value for the returned response. - return_value = resources.Property() - # 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 + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.Property.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_update_reporting_data_annotation_async( + transport: str = "grpc_asyncio", + request_type=analytics_admin.UpdateReportingDataAnnotationRequest, +): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - 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"} + # 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 = client.create_property(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + ) + response = await client.update_reporting_data_annotation(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = analytics_admin.UpdateReportingDataAnnotationRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, resources.ReportingDataAnnotation) + assert response.name == "name_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True -def test_create_property_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.create_property._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("property",))) +@pytest.mark.asyncio +async def test_update_reporting_data_annotation_async_from_dict(): + await test_update_reporting_data_annotation_async(request_type=dict) -def test_create_property_rest_flattened(): +def test_update_reporting_data_annotation_field_headers(): client = AnalyticsAdminServiceClient( 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.Property() - - # get arguments that satisfy an http rule for this method - sample_request = {} + # 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 = analytics_admin.UpdateReportingDataAnnotationRequest() - # get truthy value for each flattened field - mock_args = dict( - property=resources.Property(name="name_value"), - ) - mock_args.update(sample_request) + request.reporting_data_annotation.name = "name_value" - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.Property.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"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + call.return_value = resources.ReportingDataAnnotation() + client.update_reporting_data_annotation(request) - client.create_property(**mock_args) + # 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 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/properties" % client.transport._host, args[1] - ) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "reporting_data_annotation.name=name_value", + ) in kw["metadata"] -def test_create_property_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, +@pytest.mark.asyncio +async def test_update_reporting_data_annotation_field_headers_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.create_property( - analytics_admin.CreatePropertyRequest(), - property=resources.Property(name="name_value"), - ) - - -def test_delete_property_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() + # 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 = analytics_admin.UpdateReportingDataAnnotationRequest() - # Ensure method has been cached - assert client._transport.delete_property in client._transport._wrapped_methods + request.reporting_data_annotation.name = "name_value" - # 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. + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation() ) - client._transport._wrapped_methods[client._transport.delete_property] = mock_rpc - - request = {} - client.delete_property(request) + await client.update_reporting_data_annotation(request) # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.delete_property(request) - - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + assert 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", + "reporting_data_annotation.name=name_value", + ) in kw["metadata"] -def test_delete_property_rest_required_fields( - request_type=analytics_admin.DeletePropertyRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - 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) +def test_update_reporting_data_annotation_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_property._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" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.update_reporting_data_annotation( + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_property._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # 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].reporting_data_annotation + mock_val = resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ) + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" +def test_update_reporting_data_annotation_flattened_error(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = resources.Property() - # 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 + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_reporting_data_annotation( + analytics_admin.UpdateReportingDataAnnotationRequest(), + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.Property.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_update_reporting_data_annotation_flattened_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - 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"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = resources.ReportingDataAnnotation() - response = client.delete_property(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.update_reporting_data_annotation( + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # 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].reporting_data_annotation + mock_val = resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ) + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val -def test_delete_property_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_update_reporting_data_annotation_flattened_error_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.delete_property._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.update_reporting_data_annotation( + analytics_admin.UpdateReportingDataAnnotationRequest(), + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) -def test_delete_property_rest_flattened(): +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.DeleteReportingDataAnnotationRequest, + dict, + ], +) +def test_delete_reporting_data_annotation(request_type, transport: str = "grpc"): client = AnalyticsAdminServiceClient( 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 = resources.Property() - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) + # 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() - # 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.Property.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"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_reporting_data_annotation(request) - client.delete_property(**mock_args) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = analytics_admin.DeleteReportingDataAnnotationRequest() + assert args[0] == 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/v1alpha/{name=properties/*}" % client.transport._host, args[1] - ) + # Establish that the response is the type that we expect. + assert response is None -def test_delete_property_rest_flattened_error(transport: str = "rest"): +def test_delete_reporting_data_annotation_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="grpc", ) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.delete_property( - analytics_admin.DeletePropertyRequest(), + # 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 = analytics_admin.DeleteReportingDataAnnotationRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_reporting_data_annotation(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == analytics_admin.DeleteReportingDataAnnotationRequest( name="name_value", ) -def test_update_property_rest_use_cached_wrapped_rpc(): +def test_delete_reporting_data_annotation_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -58040,183 +58264,338 @@ def test_update_property_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_property in client._transport._wrapped_methods + assert ( + client._transport.delete_reporting_data_annotation + 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_property] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.delete_reporting_data_annotation + ] = mock_rpc request = {} - client.update_property(request) + client.delete_reporting_data_annotation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_property(request) + client.delete_reporting_data_annotation(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_property_rest_required_fields( - request_type=analytics_admin.UpdatePropertyRequest, +@pytest.mark.asyncio +async def test_delete_reporting_data_annotation_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.AnalyticsAdminServiceRestTransport + # 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 = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - 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) + # 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_reporting_data_annotation + 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_reporting_data_annotation + ] = mock_rpc + + request = {} + await client.delete_reporting_data_annotation(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.delete_reporting_data_annotation(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_reporting_data_annotation_async( + transport: str = "grpc_asyncio", + request_type=analytics_admin.DeleteReportingDataAnnotationRequest, +): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - # verify fields with default values are dropped + # 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() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_property._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_reporting_data_annotation(request) - # verify required fields with default values are now present + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = analytics_admin.DeleteReportingDataAnnotationRequest() + assert args[0] == request - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_property._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) + # Establish that the response is the type that we expect. + assert response is None - # verify required fields with non-default values are left alone +@pytest.mark.asyncio +async def test_delete_reporting_data_annotation_async_from_dict(): + await test_delete_reporting_data_annotation_async(request_type=dict) + + +def test_delete_reporting_data_annotation_field_headers(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = resources.Property() - # 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 + # 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 = analytics_admin.DeleteReportingDataAnnotationRequest() - response_value = Response() - response_value.status_code = 200 + request.name = "name_value" - # Convert return value to protobuf type - return_value = resources.Property.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + call.return_value = None + client.delete_reporting_data_annotation(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 underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request - response = client.update_property(request) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] - 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_delete_reporting_data_annotation_field_headers_async(): + client = AnalyticsAdminServiceAsyncClient( + 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 = analytics_admin.DeleteReportingDataAnnotationRequest() -def test_update_property_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_reporting_data_annotation(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_reporting_data_annotation_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.update_property._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "property", - "updateMask", - ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__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_reporting_data_annotation( + 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_update_property_rest_flattened(): +def test_delete_reporting_data_annotation_flattened_error(): client = AnalyticsAdminServiceClient( 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.Property() + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_reporting_data_annotation( + analytics_admin.DeleteReportingDataAnnotationRequest(), + name="name_value", + ) - # get arguments that satisfy an http rule for this method - sample_request = {"property": {"name": "properties/sample1"}} - # get truthy value for each flattened field - mock_args = dict( - property=resources.Property(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) - mock_args.update(sample_request) +@pytest.mark.asyncio +async def test_delete_reporting_data_annotation_flattened_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - # 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.Property.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"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None - client.update_property(**mock_args) + 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_reporting_data_annotation( + name="name_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1alpha/{property.name=properties/*}" % client.transport._host, args[1] + 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_reporting_data_annotation_flattened_error_async(): + client = AnalyticsAdminServiceAsyncClient( + 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_reporting_data_annotation( + analytics_admin.DeleteReportingDataAnnotationRequest(), + name="name_value", ) -def test_update_property_rest_flattened_error(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.SubmitUserDeletionRequest, + dict, + ], +) +def test_submit_user_deletion(request_type, transport: str = "grpc"): client = AnalyticsAdminServiceClient( 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_property( - analytics_admin.UpdatePropertyRequest(), - property=resources.Property(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + # 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.submit_user_deletion), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = analytics_admin.SubmitUserDeletionResponse() + response = client.submit_user_deletion(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = analytics_admin.SubmitUserDeletionRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, analytics_admin.SubmitUserDeletionResponse) + + +def test_submit_user_deletion_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 = AnalyticsAdminServiceClient( + 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 = analytics_admin.SubmitUserDeletionRequest( + user_id="user_id_value", + client_id="client_id_value", + app_instance_id="app_instance_id_value", + user_provided_data="user_provided_data_value", + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.submit_user_deletion(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == analytics_admin.SubmitUserDeletionRequest( + user_id="user_id_value", + client_id="client_id_value", + app_instance_id="app_instance_id_value", + user_provided_data="user_provided_data_value", + name="name_value", ) -def test_create_firebase_link_rest_use_cached_wrapped_rpc(): +def test_submit_user_deletion_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -58225,7 +58604,7 @@ def test_create_firebase_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_firebase_link in client._transport._wrapped_methods + client._transport.submit_user_deletion in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -58234,175 +58613,254 @@ def test_create_firebase_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_firebase_link + client._transport.submit_user_deletion ] = mock_rpc - request = {} - client.create_firebase_link(request) + client.submit_user_deletion(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_firebase_link(request) + client.submit_user_deletion(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_firebase_link_rest_required_fields( - request_type=analytics_admin.CreateFirebaseLinkRequest, +@pytest.mark.asyncio +async def test_submit_user_deletion_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.AnalyticsAdminServiceRestTransport + # 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 = AnalyticsAdminServiceAsyncClient( + 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() + + # Ensure method has been cached + assert ( + client._client._transport.submit_user_deletion + 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.submit_user_deletion + ] = mock_rpc + + request = {} + await client.submit_user_deletion(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.submit_user_deletion(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_submit_user_deletion_async( + transport: str = "grpc_asyncio", + request_type=analytics_admin.SubmitUserDeletionRequest, +): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - # verify fields with default values are dropped + # 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() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_firebase_link._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.SubmitUserDeletionResponse() + ) + response = await client.submit_user_deletion(request) - # verify required fields with default values are now present + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = analytics_admin.SubmitUserDeletionRequest() + assert args[0] == request - jsonified_request["parent"] = "parent_value" + # Establish that the response is the type that we expect. + assert isinstance(response, analytics_admin.SubmitUserDeletionResponse) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_firebase_link._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" +@pytest.mark.asyncio +async def test_submit_user_deletion_async_from_dict(): + await test_submit_user_deletion_async(request_type=dict) + +def test_submit_user_deletion_field_headers(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = resources.FirebaseLink() - # 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 + # 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 = analytics_admin.SubmitUserDeletionRequest() - # Convert return value to protobuf type - return_value = resources.FirebaseLink.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + request.name = "name_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"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + call.return_value = analytics_admin.SubmitUserDeletionResponse() + client.submit_user_deletion(request) - response = client.create_firebase_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 - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # 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_create_firebase_link_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_submit_user_deletion_field_headers_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.create_firebase_link._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "firebaseLink", - ) + # 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 = analytics_admin.SubmitUserDeletionRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.SubmitUserDeletionResponse() ) - ) + await client.submit_user_deletion(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request -def test_create_firebase_link_rest_flattened(): + # 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_submit_user_deletion_flattened(): client = AnalyticsAdminServiceClient( 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.FirebaseLink() + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = analytics_admin.SubmitUserDeletionResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.submit_user_deletion( + name="name_value", + ) - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + # 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 - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - firebase_link=resources.FirebaseLink(name="name_value"), + +def test_submit_user_deletion_flattened_error(): + client = AnalyticsAdminServiceClient( + 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.submit_user_deletion( + analytics_admin.SubmitUserDeletionRequest(), + 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.FirebaseLink.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_firebase_link(**mock_args) +@pytest.mark.asyncio +async def test_submit_user_deletion_flattened_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = analytics_admin.SubmitUserDeletionResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.SubmitUserDeletionResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.submit_user_deletion( + name="name_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1alpha/{parent=properties/*}/firebaseLinks" % client.transport._host, - args[1], - ) + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val -def test_create_firebase_link_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, +@pytest.mark.asyncio +async def test_submit_user_deletion_flattened_error_async(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_firebase_link( - analytics_admin.CreateFirebaseLinkRequest(), - parent="parent_value", - firebase_link=resources.FirebaseLink(name="name_value"), + await client.submit_user_deletion( + analytics_admin.SubmitUserDeletionRequest(), + name="name_value", ) -def test_delete_firebase_link_rest_use_cached_wrapped_rpc(): +def test_get_account_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: @@ -58416,34 +58874,30 @@ def test_delete_firebase_link_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_firebase_link in client._transport._wrapped_methods - ) + assert client._transport.get_account 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_firebase_link - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_account] = mock_rpc request = {} - client.delete_firebase_link(request) + client.get_account(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_firebase_link(request) + client.get_account(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_firebase_link_rest_required_fields( - request_type=analytics_admin.DeleteFirebaseLinkRequest, +def test_get_account_rest_required_fields( + request_type=analytics_admin.GetAccountRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -58459,7 +58913,7 @@ def test_delete_firebase_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_firebase_link._get_unset_required_fields(jsonified_request) + ).get_account._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -58468,7 +58922,7 @@ def test_delete_firebase_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_firebase_link._get_unset_required_fields(jsonified_request) + ).get_account._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -58482,7 +58936,7 @@ def test_delete_firebase_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.Account() # 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 @@ -58494,36 +58948,39 @@ def test_delete_firebase_link_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.Account.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_firebase_link(request) + response = client.get_account(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_firebase_link_rest_unset_required_fields(): +def test_get_account_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_firebase_link._get_unset_required_fields({}) + unset_fields = transport.get_account._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_firebase_link_rest_flattened(): +def test_get_account_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -58532,10 +58989,10 @@ def test_delete_firebase_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 = resources.Account() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/firebaseLinks/sample2"} + sample_request = {"name": "accounts/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -58546,24 +59003,25 @@ def test_delete_firebase_link_rest_flattened(): # 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 = resources.Account.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_firebase_link(**mock_args) + client.get_account(**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=properties/*/firebaseLinks/*}" % client.transport._host, - args[1], + "%s/v1alpha/{name=accounts/*}" % client.transport._host, args[1] ) -def test_delete_firebase_link_rest_flattened_error(transport: str = "rest"): +def test_get_account_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -58572,13 +59030,13 @@ def test_delete_firebase_link_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_firebase_link( - analytics_admin.DeleteFirebaseLinkRequest(), + client.get_account( + analytics_admin.GetAccountRequest(), name="name_value", ) -def test_list_firebase_links_rest_use_cached_wrapped_rpc(): +def test_list_accounts_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: @@ -58592,189 +59050,29 @@ def test_list_firebase_links_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_firebase_links in client._transport._wrapped_methods - ) + assert client._transport.list_accounts 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_firebase_links - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_accounts] = mock_rpc request = {} - client.list_firebase_links(request) + client.list_accounts(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_firebase_links(request) + client.list_accounts(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_firebase_links_rest_required_fields( - request_type=analytics_admin.ListFirebaseLinksRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - - 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_firebase_links._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_firebase_links._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) - jsonified_request.update(unset_fields) - - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" - - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListFirebaseLinksResponse() - # 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 = analytics_admin.ListFirebaseLinksResponse.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_firebase_links(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_list_firebase_links_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.list_firebase_links._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) - - -def test_list_firebase_links_rest_flattened(): - client = AnalyticsAdminServiceClient( - 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 = analytics_admin.ListFirebaseLinksResponse() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = analytics_admin.ListFirebaseLinksResponse.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_firebase_links(**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=properties/*}/firebaseLinks" % client.transport._host, - args[1], - ) - - -def test_list_firebase_links_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_firebase_links( - analytics_admin.ListFirebaseLinksRequest(), - parent="parent_value", - ) - - -def test_list_firebase_links_rest_pager(transport: str = "rest"): +def test_list_accounts_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -58786,28 +59084,28 @@ def test_list_firebase_links_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListFirebaseLinksResponse( - firebase_links=[ - resources.FirebaseLink(), - resources.FirebaseLink(), - resources.FirebaseLink(), + analytics_admin.ListAccountsResponse( + accounts=[ + resources.Account(), + resources.Account(), + resources.Account(), ], next_page_token="abc", ), - analytics_admin.ListFirebaseLinksResponse( - firebase_links=[], + analytics_admin.ListAccountsResponse( + accounts=[], next_page_token="def", ), - analytics_admin.ListFirebaseLinksResponse( - firebase_links=[ - resources.FirebaseLink(), + analytics_admin.ListAccountsResponse( + accounts=[ + resources.Account(), ], next_page_token="ghi", ), - analytics_admin.ListFirebaseLinksResponse( - firebase_links=[ - resources.FirebaseLink(), - resources.FirebaseLink(), + analytics_admin.ListAccountsResponse( + accounts=[ + resources.Account(), + resources.Account(), ], ), ) @@ -58816,7 +59114,7 @@ def test_list_firebase_links_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListFirebaseLinksResponse.to_json(x) for x in response + analytics_admin.ListAccountsResponse.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): @@ -58824,20 +59122,20 @@ def test_list_firebase_links_rest_pager(transport: str = "rest"): return_val.status_code = 200 req.side_effect = return_values - sample_request = {"parent": "properties/sample1"} + sample_request = {} - pager = client.list_firebase_links(request=sample_request) + pager = client.list_accounts(request=sample_request) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.FirebaseLink) for i in results) + assert all(isinstance(i, resources.Account) for i in results) - pages = list(client.list_firebase_links(request=sample_request).pages) + pages = list(client.list_accounts(request=sample_request).pages) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_get_global_site_tag_rest_use_cached_wrapped_rpc(): +def test_delete_account_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: @@ -58851,34 +59149,30 @@ def test_get_global_site_tag_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_global_site_tag in client._transport._wrapped_methods - ) + assert client._transport.delete_account 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_global_site_tag - ] = mock_rpc + client._transport._wrapped_methods[client._transport.delete_account] = mock_rpc request = {} - client.get_global_site_tag(request) + client.delete_account(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_global_site_tag(request) + client.delete_account(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_global_site_tag_rest_required_fields( - request_type=analytics_admin.GetGlobalSiteTagRequest, +def test_delete_account_rest_required_fields( + request_type=analytics_admin.DeleteAccountRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -58894,7 +59188,7 @@ def test_get_global_site_tag_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_global_site_tag._get_unset_required_fields(jsonified_request) + ).delete_account._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -58903,7 +59197,7 @@ def test_get_global_site_tag_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_global_site_tag._get_unset_required_fields(jsonified_request) + ).delete_account._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -58917,7 +59211,7 @@ def test_get_global_site_tag_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.GlobalSiteTag() + 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 @@ -58929,39 +59223,36 @@ def test_get_global_site_tag_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "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.GlobalSiteTag.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"} - response = client.get_global_site_tag(request) + response = client.delete_account(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_global_site_tag_rest_unset_required_fields(): +def test_delete_account_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_global_site_tag._get_unset_required_fields({}) + unset_fields = transport.delete_account._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_global_site_tag_rest_flattened(): +def test_delete_account_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -58970,12 +59261,10 @@ def test_get_global_site_tag_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.GlobalSiteTag() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/globalSiteTag" - } + sample_request = {"name": "accounts/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -58986,27 +59275,23 @@ def test_get_global_site_tag_rest_flattened(): # 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.GlobalSiteTag.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.get_global_site_tag(**mock_args) + client.delete_account(**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=properties/*/dataStreams/*/globalSiteTag}" - % client.transport._host, - args[1], + "%s/v1alpha/{name=accounts/*}" % client.transport._host, args[1] ) -def test_get_global_site_tag_rest_flattened_error(transport: str = "rest"): +def test_delete_account_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -59015,13 +59300,13 @@ def test_get_global_site_tag_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_global_site_tag( - analytics_admin.GetGlobalSiteTagRequest(), + client.delete_account( + analytics_admin.DeleteAccountRequest(), name="name_value", ) -def test_create_google_ads_link_rest_use_cached_wrapped_rpc(): +def test_update_account_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: @@ -59035,40 +59320,34 @@ def test_create_google_ads_link_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.create_google_ads_link - in client._transport._wrapped_methods - ) + assert client._transport.update_account 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_google_ads_link - ] = mock_rpc + client._transport._wrapped_methods[client._transport.update_account] = mock_rpc request = {} - client.create_google_ads_link(request) + client.update_account(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_google_ads_link(request) + client.update_account(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_google_ads_link_rest_required_fields( - request_type=analytics_admin.CreateGoogleAdsLinkRequest, +def test_update_account_rest_required_fields( + request_type=analytics_admin.UpdateAccountRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -59079,21 +59358,19 @@ def test_create_google_ads_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_google_ads_link._get_unset_required_fields(jsonified_request) + ).update_account._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_google_ads_link._get_unset_required_fields(jsonified_request) + ).update_account._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -59102,7 +59379,7 @@ def test_create_google_ads_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.GoogleAdsLink() + return_value = resources.Account() # 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 @@ -59114,7 +59391,7 @@ def test_create_google_ads_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -59124,38 +59401,38 @@ def test_create_google_ads_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleAdsLink.pb(return_value) + return_value = resources.Account.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.create_google_ads_link(request) + response = client.update_account(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_google_ads_link_rest_unset_required_fields(): +def test_update_account_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_google_ads_link._get_unset_required_fields({}) + unset_fields = transport.update_account._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) + set(("updateMask",)) & set( ( - "parent", - "googleAdsLink", + "account", + "updateMask", ) ) ) -def test_create_google_ads_link_rest_flattened(): +def test_update_account_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -59164,15 +59441,15 @@ def test_create_google_ads_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.GoogleAdsLink() + return_value = resources.Account() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"account": {"name": "accounts/sample1"}} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - google_ads_link=resources.GoogleAdsLink(name="name_value"), + account=resources.Account(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -59180,25 +59457,24 @@ def test_create_google_ads_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleAdsLink.pb(return_value) + return_value = resources.Account.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_google_ads_link(**mock_args) + client.update_account(**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=properties/*}/googleAdsLinks" % client.transport._host, - args[1], + "%s/v1alpha/{account.name=accounts/*}" % client.transport._host, args[1] ) -def test_create_google_ads_link_rest_flattened_error(transport: str = "rest"): +def test_update_account_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -59207,14 +59483,14 @@ def test_create_google_ads_link_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_google_ads_link( - analytics_admin.CreateGoogleAdsLinkRequest(), - parent="parent_value", - google_ads_link=resources.GoogleAdsLink(name="name_value"), + client.update_account( + analytics_admin.UpdateAccountRequest(), + account=resources.Account(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_google_ads_link_rest_use_cached_wrapped_rpc(): +def test_provision_account_ticket_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: @@ -59229,7 +59505,7 @@ def test_update_google_ads_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_google_ads_link + client._transport.provision_account_ticket in client._transport._wrapped_methods ) @@ -59239,167 +59515,127 @@ def test_update_google_ads_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_google_ads_link + client._transport.provision_account_ticket ] = mock_rpc request = {} - client.update_google_ads_link(request) + client.provision_account_ticket(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_google_ads_link(request) + client.provision_account_ticket(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_google_ads_link_rest_required_fields( - request_type=analytics_admin.UpdateGoogleAdsLinkRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport +def test_list_account_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - 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) - ) + # 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._transport.list_account_summaries + in client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_google_ads_link._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # 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_account_summaries + ] = mock_rpc - # verify required fields with default values are now present + request = {} + client.list_account_summaries(request) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_google_ads_link._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) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # verify required fields with non-default values are left alone + client.list_account_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_account_summaries_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = resources.GoogleAdsLink() # 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 + # 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 = ( + analytics_admin.ListAccountSummariesResponse( + account_summaries=[ + resources.AccountSummary(), + resources.AccountSummary(), + resources.AccountSummary(), + ], + next_page_token="abc", + ), + analytics_admin.ListAccountSummariesResponse( + account_summaries=[], + next_page_token="def", + ), + analytics_admin.ListAccountSummariesResponse( + account_summaries=[ + resources.AccountSummary(), + ], + next_page_token="ghi", + ), + analytics_admin.ListAccountSummariesResponse( + account_summaries=[ + resources.AccountSummary(), + resources.AccountSummary(), + ], + ), + ) + # Two responses for two calls + response = response + response - response_value = Response() - response_value.status_code = 200 + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListAccountSummariesResponse.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 - # Convert return value to protobuf type - return_value = resources.GoogleAdsLink.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + sample_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"} + pager = client.list_account_summaries(request=sample_request) - response = client.update_google_ads_link(request) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.AccountSummary) for i in results) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_update_google_ads_link_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.update_google_ads_link._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) - - -def test_update_google_ads_link_rest_flattened(): - client = AnalyticsAdminServiceClient( - 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.GoogleAdsLink() - - # get arguments that satisfy an http rule for this method - sample_request = { - "google_ads_link": {"name": "properties/sample1/googleAdsLinks/sample2"} - } - - # get truthy value for each flattened field - mock_args = dict( - google_ads_link=resources.GoogleAdsLink(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 = resources.GoogleAdsLink.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.update_google_ads_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/{google_ads_link.name=properties/*/googleAdsLinks/*}" - % client.transport._host, - args[1], - ) - - -def test_update_google_ads_link_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_google_ads_link( - analytics_admin.UpdateGoogleAdsLinkRequest(), - google_ads_link=resources.GoogleAdsLink(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) + pages = list(client.list_account_summaries(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_delete_google_ads_link_rest_use_cached_wrapped_rpc(): +def test_get_property_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: @@ -59413,35 +59649,30 @@ def test_delete_google_ads_link_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_google_ads_link - in client._transport._wrapped_methods - ) + assert client._transport.get_property 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_google_ads_link - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_property] = mock_rpc request = {} - client.delete_google_ads_link(request) + client.get_property(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_google_ads_link(request) + client.get_property(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_google_ads_link_rest_required_fields( - request_type=analytics_admin.DeleteGoogleAdsLinkRequest, +def test_get_property_rest_required_fields( + request_type=analytics_admin.GetPropertyRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -59457,7 +59688,7 @@ def test_delete_google_ads_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_google_ads_link._get_unset_required_fields(jsonified_request) + ).get_property._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -59466,7 +59697,7 @@ def test_delete_google_ads_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_google_ads_link._get_unset_required_fields(jsonified_request) + ).get_property._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -59480,7 +59711,7 @@ def test_delete_google_ads_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.Property() # 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 @@ -59492,36 +59723,39 @@ def test_delete_google_ads_link_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.Property.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_google_ads_link(request) + response = client.get_property(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_google_ads_link_rest_unset_required_fields(): +def test_get_property_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_google_ads_link._get_unset_required_fields({}) + unset_fields = transport.get_property._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_google_ads_link_rest_flattened(): +def test_get_property_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -59530,10 +59764,10 @@ def test_delete_google_ads_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 = resources.Property() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/googleAdsLinks/sample2"} + sample_request = {"name": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -59544,24 +59778,25 @@ def test_delete_google_ads_link_rest_flattened(): # 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 = resources.Property.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_google_ads_link(**mock_args) + client.get_property(**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=properties/*/googleAdsLinks/*}" % client.transport._host, - args[1], + "%s/v1alpha/{name=properties/*}" % client.transport._host, args[1] ) -def test_delete_google_ads_link_rest_flattened_error(transport: str = "rest"): +def test_get_property_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -59570,13 +59805,13 @@ def test_delete_google_ads_link_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_google_ads_link( - analytics_admin.DeleteGoogleAdsLinkRequest(), + client.get_property( + analytics_admin.GetPropertyRequest(), name="name_value", ) -def test_list_google_ads_links_rest_use_cached_wrapped_rpc(): +def test_list_properties_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: @@ -59590,40 +59825,35 @@ def test_list_google_ads_links_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_google_ads_links - in client._transport._wrapped_methods - ) + assert client._transport.list_properties 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_google_ads_links - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_properties] = mock_rpc request = {} - client.list_google_ads_links(request) + client.list_properties(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_google_ads_links(request) + client.list_properties(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_google_ads_links_rest_required_fields( - request_type=analytics_admin.ListGoogleAdsLinksRequest, +def test_list_properties_rest_required_fields( + request_type=analytics_admin.ListPropertiesRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["filter"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -59631,31 +59861,36 @@ def test_list_google_ads_links_rest_required_fields( ) # verify fields with default values are dropped + assert "filter" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_google_ads_links._get_unset_required_fields(jsonified_request) + ).list_properties._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "filter" in jsonified_request + assert jsonified_request["filter"] == request_init["filter"] - jsonified_request["parent"] = "parent_value" + jsonified_request["filter"] = "filter_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_google_ads_links._get_unset_required_fields(jsonified_request) + ).list_properties._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( + "filter", "page_size", "page_token", + "show_deleted", ) ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "filter" in jsonified_request + assert jsonified_request["filter"] == "filter_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -59664,7 +59899,7 @@ def test_list_google_ads_links_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListGoogleAdsLinksResponse() + return_value = analytics_admin.ListPropertiesResponse() # 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 @@ -59685,95 +59920,46 @@ def test_list_google_ads_links_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListGoogleAdsLinksResponse.pb(return_value) + return_value = analytics_admin.ListPropertiesResponse.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_google_ads_links(request) + response = client.list_properties(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "filter", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_google_ads_links_rest_unset_required_fields(): +def test_list_properties_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_google_ads_links._get_unset_required_fields({}) + unset_fields = transport.list_properties._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( + "filter", "pageSize", "pageToken", + "showDeleted", ) ) - & set(("parent",)) - ) - - -def test_list_google_ads_links_rest_flattened(): - client = AnalyticsAdminServiceClient( - 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 = analytics_admin.ListGoogleAdsLinksResponse() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} - - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = analytics_admin.ListGoogleAdsLinksResponse.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_google_ads_links(**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=properties/*}/googleAdsLinks" % client.transport._host, - args[1], - ) - - -def test_list_google_ads_links_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + & set(("filter",)) ) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.list_google_ads_links( - analytics_admin.ListGoogleAdsLinksRequest(), - parent="parent_value", - ) - -def test_list_google_ads_links_rest_pager(transport: str = "rest"): +def test_list_properties_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -59785,28 +59971,28 @@ def test_list_google_ads_links_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListGoogleAdsLinksResponse( - google_ads_links=[ - resources.GoogleAdsLink(), - resources.GoogleAdsLink(), - resources.GoogleAdsLink(), + analytics_admin.ListPropertiesResponse( + properties=[ + resources.Property(), + resources.Property(), + resources.Property(), ], next_page_token="abc", ), - analytics_admin.ListGoogleAdsLinksResponse( - google_ads_links=[], + analytics_admin.ListPropertiesResponse( + properties=[], next_page_token="def", ), - analytics_admin.ListGoogleAdsLinksResponse( - google_ads_links=[ - resources.GoogleAdsLink(), + analytics_admin.ListPropertiesResponse( + properties=[ + resources.Property(), ], next_page_token="ghi", ), - analytics_admin.ListGoogleAdsLinksResponse( - google_ads_links=[ - resources.GoogleAdsLink(), - resources.GoogleAdsLink(), + analytics_admin.ListPropertiesResponse( + properties=[ + resources.Property(), + resources.Property(), ], ), ) @@ -59815,7 +60001,7 @@ def test_list_google_ads_links_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListGoogleAdsLinksResponse.to_json(x) for x in response + analytics_admin.ListPropertiesResponse.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): @@ -59823,20 +60009,20 @@ def test_list_google_ads_links_rest_pager(transport: str = "rest"): return_val.status_code = 200 req.side_effect = return_values - sample_request = {"parent": "properties/sample1"} + sample_request = {} - pager = client.list_google_ads_links(request=sample_request) + pager = client.list_properties(request=sample_request) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.GoogleAdsLink) for i in results) + assert all(isinstance(i, resources.Property) for i in results) - pages = list(client.list_google_ads_links(request=sample_request).pages) + pages = list(client.list_properties(request=sample_request).pages) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_get_data_sharing_settings_rest_use_cached_wrapped_rpc(): +def test_create_property_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: @@ -59850,40 +60036,34 @@ def test_get_data_sharing_settings_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_data_sharing_settings - in client._transport._wrapped_methods - ) + assert client._transport.create_property 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_data_sharing_settings - ] = mock_rpc + client._transport._wrapped_methods[client._transport.create_property] = mock_rpc request = {} - client.get_data_sharing_settings(request) + client.create_property(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_data_sharing_settings(request) + client.create_property(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_data_sharing_settings_rest_required_fields( - request_type=analytics_admin.GetDataSharingSettingsRequest, +def test_create_property_rest_required_fields( + request_type=analytics_admin.CreatePropertyRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -59894,21 +60074,17 @@ def test_get_data_sharing_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_sharing_settings._get_unset_required_fields(jsonified_request) + ).create_property._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_data_sharing_settings._get_unset_required_fields(jsonified_request) + ).create_property._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -59917,7 +60093,7 @@ def test_get_data_sharing_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataSharingSettings() + return_value = resources.Property() # 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 @@ -59929,39 +60105,40 @@ def test_get_data_sharing_settings_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.DataSharingSettings.pb(return_value) + return_value = resources.Property.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_data_sharing_settings(request) + response = client.create_property(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_data_sharing_settings_rest_unset_required_fields(): +def test_create_property_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_data_sharing_settings._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_property._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("property",))) -def test_get_data_sharing_settings_rest_flattened(): +def test_create_property_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -59970,14 +60147,14 @@ def test_get_data_sharing_settings_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.DataSharingSettings() + return_value = resources.Property() # get arguments that satisfy an http rule for this method - sample_request = {"name": "accounts/sample1/dataSharingSettings"} + sample_request = {} # get truthy value for each flattened field mock_args = dict( - name="name_value", + property=resources.Property(name="name_value"), ) mock_args.update(sample_request) @@ -59985,25 +60162,24 @@ def test_get_data_sharing_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataSharingSettings.pb(return_value) + return_value = resources.Property.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_data_sharing_settings(**mock_args) + client.create_property(**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=accounts/*/dataSharingSettings}" % client.transport._host, - args[1], + "%s/v1alpha/properties" % client.transport._host, args[1] ) -def test_get_data_sharing_settings_rest_flattened_error(transport: str = "rest"): +def test_create_property_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -60012,13 +60188,13 @@ def test_get_data_sharing_settings_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_data_sharing_settings( - analytics_admin.GetDataSharingSettingsRequest(), - name="name_value", + client.create_property( + analytics_admin.CreatePropertyRequest(), + property=resources.Property(name="name_value"), ) -def test_get_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): +def test_delete_property_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: @@ -60032,35 +60208,30 @@ def test_get_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_measurement_protocol_secret - in client._transport._wrapped_methods - ) + assert client._transport.delete_property 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_measurement_protocol_secret - ] = mock_rpc + client._transport._wrapped_methods[client._transport.delete_property] = mock_rpc request = {} - client.get_measurement_protocol_secret(request) + client.delete_property(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_measurement_protocol_secret(request) + client.delete_property(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_measurement_protocol_secret_rest_required_fields( - request_type=analytics_admin.GetMeasurementProtocolSecretRequest, +def test_delete_property_rest_required_fields( + request_type=analytics_admin.DeletePropertyRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -60076,7 +60247,7 @@ def test_get_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).delete_property._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -60085,7 +60256,7 @@ def test_get_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).delete_property._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -60099,7 +60270,7 @@ def test_get_measurement_protocol_secret_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.MeasurementProtocolSecret() + return_value = resources.Property() # 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 @@ -60111,7 +60282,7 @@ def test_get_measurement_protocol_secret_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "query_params": pb_request, } transcode.return_value = transcode_result @@ -60120,32 +60291,30 @@ def test_get_measurement_protocol_secret_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = resources.Property.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_measurement_protocol_secret(request) + response = client.delete_property(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_measurement_protocol_secret_rest_unset_required_fields(): +def test_delete_property_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_measurement_protocol_secret._get_unset_required_fields( - {} - ) + unset_fields = transport.delete_property._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_measurement_protocol_secret_rest_flattened(): +def test_delete_property_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -60154,12 +60323,10 @@ def test_get_measurement_protocol_secret_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.MeasurementProtocolSecret() + return_value = resources.Property() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + sample_request = {"name": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -60171,26 +60338,24 @@ def test_get_measurement_protocol_secret_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = resources.Property.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_measurement_protocol_secret(**mock_args) + client.delete_property(**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=properties/*/dataStreams/*/measurementProtocolSecrets/*}" - % client.transport._host, - args[1], + "%s/v1alpha/{name=properties/*}" % client.transport._host, args[1] ) -def test_get_measurement_protocol_secret_rest_flattened_error(transport: str = "rest"): +def test_delete_property_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -60199,13 +60364,13 @@ def test_get_measurement_protocol_secret_rest_flattened_error(transport: str = " # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_measurement_protocol_secret( - analytics_admin.GetMeasurementProtocolSecretRequest(), + client.delete_property( + analytics_admin.DeletePropertyRequest(), name="name_value", ) -def test_list_measurement_protocol_secrets_rest_use_cached_wrapped_rpc(): +def test_update_property_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: @@ -60219,40 +60384,34 @@ def test_list_measurement_protocol_secrets_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_measurement_protocol_secrets - in client._transport._wrapped_methods - ) + assert client._transport.update_property 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_measurement_protocol_secrets - ] = mock_rpc + client._transport._wrapped_methods[client._transport.update_property] = mock_rpc request = {} - client.list_measurement_protocol_secrets(request) + client.update_property(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_measurement_protocol_secrets(request) + client.update_property(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_measurement_protocol_secrets_rest_required_fields( - request_type=analytics_admin.ListMeasurementProtocolSecretsRequest, +def test_update_property_rest_required_fields( + request_type=analytics_admin.UpdatePropertyRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -60263,28 +60422,19 @@ def test_list_measurement_protocol_secrets_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_measurement_protocol_secrets._get_unset_required_fields(jsonified_request) + ).update_property._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_measurement_protocol_secrets._get_unset_required_fields(jsonified_request) + ).update_property._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + assert not set(unset_fields) - set(("update_mask",)) 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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -60293,7 +60443,7 @@ def test_list_measurement_protocol_secrets_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() + return_value = resources.Property() # 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 @@ -60305,51 +60455,48 @@ def test_list_measurement_protocol_secrets_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 = analytics_admin.ListMeasurementProtocolSecretsResponse.pb( - return_value - ) + return_value = resources.Property.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_measurement_protocol_secrets(request) + response = client.update_property(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_measurement_protocol_secrets_rest_unset_required_fields(): +def test_update_property_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.list_measurement_protocol_secrets._get_unset_required_fields({}) - ) + unset_fields = transport.update_property._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(("updateMask",)) + & set( ( - "pageSize", - "pageToken", + "property", + "updateMask", ) ) - & set(("parent",)) ) -def test_list_measurement_protocol_secrets_rest_flattened(): +def test_update_property_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -60358,14 +60505,15 @@ def test_list_measurement_protocol_secrets_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 = analytics_admin.ListMeasurementProtocolSecretsResponse() + return_value = resources.Property() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = {"property": {"name": "properties/sample1"}} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + property=resources.Property(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -60373,30 +60521,24 @@ def test_list_measurement_protocol_secrets_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListMeasurementProtocolSecretsResponse.pb( - return_value - ) + return_value = resources.Property.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_measurement_protocol_secrets(**mock_args) + client.update_property(**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=properties/*/dataStreams/*}/measurementProtocolSecrets" - % client.transport._host, - args[1], + "%s/v1alpha/{property.name=properties/*}" % client.transport._host, args[1] ) -def test_list_measurement_protocol_secrets_rest_flattened_error( - transport: str = "rest", -): +def test_update_property_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -60405,79 +60547,14 @@ def test_list_measurement_protocol_secrets_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_measurement_protocol_secrets( - analytics_admin.ListMeasurementProtocolSecretsRequest(), - parent="parent_value", + client.update_property( + analytics_admin.UpdatePropertyRequest(), + property=resources.Property(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_list_measurement_protocol_secrets_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListMeasurementProtocolSecretsResponse( - measurement_protocol_secrets=[ - resources.MeasurementProtocolSecret(), - resources.MeasurementProtocolSecret(), - resources.MeasurementProtocolSecret(), - ], - next_page_token="abc", - ), - analytics_admin.ListMeasurementProtocolSecretsResponse( - measurement_protocol_secrets=[], - next_page_token="def", - ), - analytics_admin.ListMeasurementProtocolSecretsResponse( - measurement_protocol_secrets=[ - resources.MeasurementProtocolSecret(), - ], - next_page_token="ghi", - ), - analytics_admin.ListMeasurementProtocolSecretsResponse( - measurement_protocol_secrets=[ - resources.MeasurementProtocolSecret(), - resources.MeasurementProtocolSecret(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListMeasurementProtocolSecretsResponse.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": "properties/sample1/dataStreams/sample2"} - - pager = client.list_measurement_protocol_secrets(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.MeasurementProtocolSecret) for i in results) - - pages = list( - client.list_measurement_protocol_secrets(request=sample_request).pages - ) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_create_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): +def test_create_firebase_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: @@ -60492,8 +60569,7 @@ def test_create_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_measurement_protocol_secret - in client._transport._wrapped_methods + client._transport.create_firebase_link in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -60502,24 +60578,24 @@ def test_create_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_measurement_protocol_secret + client._transport.create_firebase_link ] = mock_rpc request = {} - client.create_measurement_protocol_secret(request) + client.create_firebase_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_measurement_protocol_secret(request) + client.create_firebase_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_create_measurement_protocol_secret_rest_required_fields( - request_type=analytics_admin.CreateMeasurementProtocolSecretRequest, +def test_create_firebase_link_rest_required_fields( + request_type=analytics_admin.CreateFirebaseLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -60535,7 +60611,7 @@ def test_create_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).create_firebase_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -60544,7 +60620,7 @@ def test_create_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).create_firebase_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -60558,7 +60634,7 @@ def test_create_measurement_protocol_secret_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.MeasurementProtocolSecret() + return_value = resources.FirebaseLink() # 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 @@ -60580,40 +60656,38 @@ def test_create_measurement_protocol_secret_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = resources.FirebaseLink.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.create_measurement_protocol_secret(request) + response = client.create_firebase_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_measurement_protocol_secret_rest_unset_required_fields(): +def test_create_firebase_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.create_measurement_protocol_secret._get_unset_required_fields({}) - ) + unset_fields = transport.create_firebase_link._get_unset_required_fields({}) assert set(unset_fields) == ( set(()) & set( ( "parent", - "measurementProtocolSecret", + "firebaseLink", ) ) ) -def test_create_measurement_protocol_secret_rest_flattened(): +def test_create_firebase_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -60622,17 +60696,15 @@ def test_create_measurement_protocol_secret_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.MeasurementProtocolSecret() + return_value = resources.FirebaseLink() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( parent="parent_value", - measurement_protocol_secret=resources.MeasurementProtocolSecret( - name="name_value" - ), + firebase_link=resources.FirebaseLink(name="name_value"), ) mock_args.update(sample_request) @@ -60640,28 +60712,25 @@ def test_create_measurement_protocol_secret_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = resources.FirebaseLink.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_measurement_protocol_secret(**mock_args) + client.create_firebase_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=properties/*/dataStreams/*}/measurementProtocolSecrets" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/firebaseLinks" % client.transport._host, args[1], ) -def test_create_measurement_protocol_secret_rest_flattened_error( - transport: str = "rest", -): +def test_create_firebase_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -60670,16 +60739,14 @@ def test_create_measurement_protocol_secret_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_measurement_protocol_secret( - analytics_admin.CreateMeasurementProtocolSecretRequest(), + client.create_firebase_link( + analytics_admin.CreateFirebaseLinkRequest(), parent="parent_value", - measurement_protocol_secret=resources.MeasurementProtocolSecret( - name="name_value" - ), + firebase_link=resources.FirebaseLink(name="name_value"), ) -def test_delete_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): +def test_delete_firebase_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: @@ -60694,8 +60761,7 @@ def test_delete_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_measurement_protocol_secret - in client._transport._wrapped_methods + client._transport.delete_firebase_link in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -60704,24 +60770,24 @@ def test_delete_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_measurement_protocol_secret + client._transport.delete_firebase_link ] = mock_rpc request = {} - client.delete_measurement_protocol_secret(request) + client.delete_firebase_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_measurement_protocol_secret(request) + client.delete_firebase_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_measurement_protocol_secret_rest_required_fields( - request_type=analytics_admin.DeleteMeasurementProtocolSecretRequest, +def test_delete_firebase_link_rest_required_fields( + request_type=analytics_admin.DeleteFirebaseLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -60737,7 +60803,7 @@ def test_delete_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).delete_firebase_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -60746,7 +60812,7 @@ def test_delete_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).delete_firebase_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -60785,25 +60851,23 @@ def test_delete_measurement_protocol_secret_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_measurement_protocol_secret(request) + response = client.delete_firebase_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_measurement_protocol_secret_rest_unset_required_fields(): +def test_delete_firebase_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.delete_measurement_protocol_secret._get_unset_required_fields({}) - ) + unset_fields = transport.delete_firebase_link._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_measurement_protocol_secret_rest_flattened(): +def test_delete_firebase_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -60815,9 +60879,7 @@ def test_delete_measurement_protocol_secret_rest_flattened(): return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + sample_request = {"name": "properties/sample1/firebaseLinks/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -60833,22 +60895,19 @@ def test_delete_measurement_protocol_secret_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_measurement_protocol_secret(**mock_args) + client.delete_firebase_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/{name=properties/*/dataStreams/*/measurementProtocolSecrets/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/firebaseLinks/*}" % client.transport._host, args[1], ) -def test_delete_measurement_protocol_secret_rest_flattened_error( - transport: str = "rest", -): +def test_delete_firebase_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -60857,13 +60916,13 @@ def test_delete_measurement_protocol_secret_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_measurement_protocol_secret( - analytics_admin.DeleteMeasurementProtocolSecretRequest(), + client.delete_firebase_link( + analytics_admin.DeleteFirebaseLinkRequest(), name="name_value", ) -def test_update_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): +def test_list_firebase_links_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: @@ -60878,8 +60937,7 @@ def test_update_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_measurement_protocol_secret - in client._transport._wrapped_methods + client._transport.list_firebase_links in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -60888,28 +60946,29 @@ def test_update_measurement_protocol_secret_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_measurement_protocol_secret + client._transport.list_firebase_links ] = mock_rpc request = {} - client.update_measurement_protocol_secret(request) + client.list_firebase_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_measurement_protocol_secret(request) + client.list_firebase_links(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_measurement_protocol_secret_rest_required_fields( - request_type=analytics_admin.UpdateMeasurementProtocolSecretRequest, +def test_list_firebase_links_rest_required_fields( + request_type=analytics_admin.ListFirebaseLinksRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -60920,19 +60979,28 @@ def test_update_measurement_protocol_secret_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).list_firebase_links._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_measurement_protocol_secret._get_unset_required_fields(jsonified_request) + ).list_firebase_links._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( + ( + "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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -60941,7 +61009,7 @@ def test_update_measurement_protocol_secret_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.MeasurementProtocolSecret() + return_value = analytics_admin.ListFirebaseLinksResponse() # 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 @@ -60953,50 +61021,47 @@ def test_update_measurement_protocol_secret_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 = resources.MeasurementProtocolSecret.pb(return_value) + return_value = analytics_admin.ListFirebaseLinksResponse.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_measurement_protocol_secret(request) + response = client.list_firebase_links(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_measurement_protocol_secret_rest_unset_required_fields(): +def test_list_firebase_links_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.update_measurement_protocol_secret._get_unset_required_fields({}) - ) + unset_fields = transport.list_firebase_links._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) - & set( + set( ( - "measurementProtocolSecret", - "updateMask", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_update_measurement_protocol_secret_rest_flattened(): +def test_list_firebase_links_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -61005,21 +61070,14 @@ def test_update_measurement_protocol_secret_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.MeasurementProtocolSecret() + return_value = analytics_admin.ListFirebaseLinksResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "measurement_protocol_secret": { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - measurement_protocol_secret=resources.MeasurementProtocolSecret( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", ) mock_args.update(sample_request) @@ -61027,28 +61085,25 @@ def test_update_measurement_protocol_secret_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = analytics_admin.ListFirebaseLinksResponse.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.update_measurement_protocol_secret(**mock_args) + client.list_firebase_links(**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/{measurement_protocol_secret.name=properties/*/dataStreams/*/measurementProtocolSecrets/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/firebaseLinks" % client.transport._host, args[1], ) -def test_update_measurement_protocol_secret_rest_flattened_error( - transport: str = "rest", -): +def test_list_firebase_links_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -61057,16 +61112,76 @@ def test_update_measurement_protocol_secret_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_measurement_protocol_secret( - analytics_admin.UpdateMeasurementProtocolSecretRequest(), - measurement_protocol_secret=resources.MeasurementProtocolSecret( - name="name_value" + client.list_firebase_links( + analytics_admin.ListFirebaseLinksRequest(), + parent="parent_value", + ) + + +def test_list_firebase_links_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListFirebaseLinksResponse( + firebase_links=[ + resources.FirebaseLink(), + resources.FirebaseLink(), + resources.FirebaseLink(), + ], + next_page_token="abc", + ), + analytics_admin.ListFirebaseLinksResponse( + firebase_links=[], + next_page_token="def", + ), + analytics_admin.ListFirebaseLinksResponse( + firebase_links=[ + resources.FirebaseLink(), + ], + next_page_token="ghi", + ), + analytics_admin.ListFirebaseLinksResponse( + firebase_links=[ + resources.FirebaseLink(), + resources.FirebaseLink(), + ], ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) + # Two responses for two calls + response = response + response + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListFirebaseLinksResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values -def test_acknowledge_user_data_collection_rest_use_cached_wrapped_rpc(): + sample_request = {"parent": "properties/sample1"} + + pager = client.list_firebase_links(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.FirebaseLink) for i in results) + + pages = list(client.list_firebase_links(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_global_site_tag_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: @@ -61081,8 +61196,7 @@ def test_acknowledge_user_data_collection_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.acknowledge_user_data_collection - in client._transport._wrapped_methods + client._transport.get_global_site_tag in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -61091,30 +61205,29 @@ def test_acknowledge_user_data_collection_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.acknowledge_user_data_collection + client._transport.get_global_site_tag ] = mock_rpc request = {} - client.acknowledge_user_data_collection(request) + client.get_global_site_tag(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.acknowledge_user_data_collection(request) + client.get_global_site_tag(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_acknowledge_user_data_collection_rest_required_fields( - request_type=analytics_admin.AcknowledgeUserDataCollectionRequest, +def test_get_global_site_tag_rest_required_fields( + request_type=analytics_admin.GetGlobalSiteTagRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["property"] = "" - request_init["acknowledgement"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -61125,24 +61238,21 @@ def test_acknowledge_user_data_collection_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).acknowledge_user_data_collection._get_unset_required_fields(jsonified_request) + ).get_global_site_tag._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["property"] = "property_value" - jsonified_request["acknowledgement"] = "acknowledgement_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).acknowledge_user_data_collection._get_unset_required_fields(jsonified_request) + ).get_global_site_tag._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "property" in jsonified_request - assert jsonified_request["property"] == "property_value" - assert "acknowledgement" in jsonified_request - assert jsonified_request["acknowledgement"] == "acknowledgement_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -61151,7 +61261,7 @@ def test_acknowledge_user_data_collection_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() + return_value = resources.GlobalSiteTag() # 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 @@ -61163,52 +61273,99 @@ def test_acknowledge_user_data_collection_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.AcknowledgeUserDataCollectionResponse.pb( - return_value - ) + return_value = resources.GlobalSiteTag.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.acknowledge_user_data_collection(request) + response = client.get_global_site_tag(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_acknowledge_user_data_collection_rest_unset_required_fields(): +def test_get_global_site_tag_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.acknowledge_user_data_collection._get_unset_required_fields({}) + unset_fields = transport.get_global_site_tag._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_global_site_tag_rest_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - assert set(unset_fields) == ( - set(()) - & set( - ( - "property", - "acknowledgement", - ) + + # 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.GlobalSiteTag() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "properties/sample1/dataStreams/sample2/globalSiteTag" + } + + # 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.GlobalSiteTag.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_global_site_tag(**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=properties/*/dataStreams/*/globalSiteTag}" + % client.transport._host, + args[1], ) + + +def test_get_global_site_tag_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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_global_site_tag( + analytics_admin.GetGlobalSiteTagRequest(), + name="name_value", + ) + -def test_get_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rpc(): +def test_create_google_ads_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: @@ -61223,7 +61380,7 @@ def test_get_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rpc() # Ensure method has been cached assert ( - client._transport.get_sk_ad_network_conversion_value_schema + client._transport.create_google_ads_link in client._transport._wrapped_methods ) @@ -61233,29 +61390,29 @@ def test_get_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rpc() "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_sk_ad_network_conversion_value_schema + client._transport.create_google_ads_link ] = mock_rpc request = {} - client.get_sk_ad_network_conversion_value_schema(request) + client.create_google_ads_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_sk_ad_network_conversion_value_schema(request) + client.create_google_ads_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_get_sk_ad_network_conversion_value_schema_rest_required_fields( - request_type=analytics_admin.GetSKAdNetworkConversionValueSchemaRequest, +def test_create_google_ads_link_rest_required_fields( + request_type=analytics_admin.CreateGoogleAdsLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -61266,25 +61423,21 @@ def test_get_sk_ad_network_conversion_value_schema_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).create_google_ads_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" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).create_google_ads_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" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -61293,7 +61446,7 @@ def test_get_sk_ad_network_conversion_value_schema_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.SKAdNetworkConversionValueSchema() + return_value = resources.GoogleAdsLink() # 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 @@ -61305,43 +61458,48 @@ def test_get_sk_ad_network_conversion_value_schema_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.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = resources.GoogleAdsLink.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_sk_ad_network_conversion_value_schema(request) + response = client.create_google_ads_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): +def test_create_google_ads_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.get_sk_ad_network_conversion_value_schema._get_unset_required_fields( - {} + unset_fields = transport.create_google_ads_link._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "googleAdsLink", + ) ) ) - assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_sk_ad_network_conversion_value_schema_rest_flattened(): +def test_create_google_ads_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -61350,16 +61508,15 @@ def test_get_sk_ad_network_conversion_value_schema_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.SKAdNetworkConversionValueSchema() + return_value = resources.GoogleAdsLink() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + google_ads_link=resources.GoogleAdsLink(name="name_value"), ) mock_args.update(sample_request) @@ -61367,28 +61524,25 @@ def test_get_sk_ad_network_conversion_value_schema_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = resources.GoogleAdsLink.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_sk_ad_network_conversion_value_schema(**mock_args) + client.create_google_ads_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/{name=properties/*/dataStreams/*/sKAdNetworkConversionValueSchema/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/googleAdsLinks" % client.transport._host, args[1], ) -def test_get_sk_ad_network_conversion_value_schema_rest_flattened_error( - transport: str = "rest", -): +def test_create_google_ads_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -61397,13 +61551,14 @@ def test_get_sk_ad_network_conversion_value_schema_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_sk_ad_network_conversion_value_schema( - analytics_admin.GetSKAdNetworkConversionValueSchemaRequest(), - name="name_value", + client.create_google_ads_link( + analytics_admin.CreateGoogleAdsLinkRequest(), + parent="parent_value", + google_ads_link=resources.GoogleAdsLink(name="name_value"), ) -def test_create_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rpc(): +def test_update_google_ads_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: @@ -61418,7 +61573,7 @@ def test_create_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rp # Ensure method has been cached assert ( - client._transport.create_sk_ad_network_conversion_value_schema + client._transport.update_google_ads_link in client._transport._wrapped_methods ) @@ -61428,29 +61583,28 @@ def test_create_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rp "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_sk_ad_network_conversion_value_schema + client._transport.update_google_ads_link ] = mock_rpc request = {} - client.create_sk_ad_network_conversion_value_schema(request) + client.update_google_ads_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_sk_ad_network_conversion_value_schema(request) + client.update_google_ads_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_create_sk_ad_network_conversion_value_schema_rest_required_fields( - request_type=analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest, +def test_update_google_ads_link_rest_required_fields( + request_type=analytics_admin.UpdateGoogleAdsLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -61461,25 +61615,19 @@ def test_create_sk_ad_network_conversion_value_schema_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).update_google_ads_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).update_google_ads_link._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -61488,7 +61636,7 @@ def test_create_sk_ad_network_conversion_value_schema_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.SKAdNetworkConversionValueSchema() + return_value = resources.GoogleAdsLink() # 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 @@ -61500,7 +61648,7 @@ def test_create_sk_ad_network_conversion_value_schema_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -61510,40 +61658,30 @@ def test_create_sk_ad_network_conversion_value_schema_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = resources.GoogleAdsLink.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.create_sk_ad_network_conversion_value_schema(request) + response = client.update_google_ads_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): +def test_update_google_ads_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_sk_ad_network_conversion_value_schema._get_unset_required_fields( - {} - ) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "skadnetworkConversionValueSchema", - ) - ) - ) + unset_fields = transport.update_google_ads_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) -def test_create_sk_ad_network_conversion_value_schema_rest_flattened(): +def test_update_google_ads_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -61552,17 +61690,17 @@ def test_create_sk_ad_network_conversion_value_schema_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.SKAdNetworkConversionValueSchema() + return_value = resources.GoogleAdsLink() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = { + "google_ads_link": {"name": "properties/sample1/googleAdsLinks/sample2"} + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( - name="name_value" - ), + google_ads_link=resources.GoogleAdsLink(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -61570,28 +61708,26 @@ def test_create_sk_ad_network_conversion_value_schema_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = resources.GoogleAdsLink.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_sk_ad_network_conversion_value_schema(**mock_args) + client.update_google_ads_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=properties/*/dataStreams/*}/sKAdNetworkConversionValueSchema" + "%s/v1alpha/{google_ads_link.name=properties/*/googleAdsLinks/*}" % client.transport._host, args[1], ) -def test_create_sk_ad_network_conversion_value_schema_rest_flattened_error( - transport: str = "rest", -): +def test_update_google_ads_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -61600,16 +61736,14 @@ def test_create_sk_ad_network_conversion_value_schema_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_sk_ad_network_conversion_value_schema( - analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest(), - parent="parent_value", - skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( - name="name_value" - ), + client.update_google_ads_link( + analytics_admin.UpdateGoogleAdsLinkRequest(), + google_ads_link=resources.GoogleAdsLink(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rpc(): +def test_delete_google_ads_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: @@ -61624,7 +61758,7 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rp # Ensure method has been cached assert ( - client._transport.delete_sk_ad_network_conversion_value_schema + client._transport.delete_google_ads_link in client._transport._wrapped_methods ) @@ -61634,24 +61768,24 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rp "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_sk_ad_network_conversion_value_schema + client._transport.delete_google_ads_link ] = mock_rpc request = {} - client.delete_sk_ad_network_conversion_value_schema(request) + client.delete_google_ads_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_sk_ad_network_conversion_value_schema(request) + client.delete_google_ads_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_sk_ad_network_conversion_value_schema_rest_required_fields( - request_type=analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, +def test_delete_google_ads_link_rest_required_fields( + request_type=analytics_admin.DeleteGoogleAdsLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -61667,9 +61801,7 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).delete_google_ads_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -61678,9 +61810,7 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).delete_google_ads_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -61719,25 +61849,23 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_sk_ad_network_conversion_value_schema(request) + response = client.delete_google_ads_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): +def test_delete_google_ads_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_sk_ad_network_conversion_value_schema._get_unset_required_fields( - {} - ) + unset_fields = transport.delete_google_ads_link._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_sk_ad_network_conversion_value_schema_rest_flattened(): +def test_delete_google_ads_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -61749,9 +61877,7 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_flattened(): return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } + sample_request = {"name": "properties/sample1/googleAdsLinks/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -61767,22 +61893,19 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_sk_ad_network_conversion_value_schema(**mock_args) + client.delete_google_ads_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/{name=properties/*/dataStreams/*/sKAdNetworkConversionValueSchema/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/googleAdsLinks/*}" % client.transport._host, args[1], ) -def test_delete_sk_ad_network_conversion_value_schema_rest_flattened_error( - transport: str = "rest", -): +def test_delete_google_ads_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -61791,13 +61914,13 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_sk_ad_network_conversion_value_schema( - analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest(), + client.delete_google_ads_link( + analytics_admin.DeleteGoogleAdsLinkRequest(), name="name_value", ) -def test_update_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rpc(): +def test_list_google_ads_links_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: @@ -61812,7 +61935,7 @@ def test_update_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rp # Ensure method has been cached assert ( - client._transport.update_sk_ad_network_conversion_value_schema + client._transport.list_google_ads_links in client._transport._wrapped_methods ) @@ -61822,28 +61945,29 @@ def test_update_sk_ad_network_conversion_value_schema_rest_use_cached_wrapped_rp "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_sk_ad_network_conversion_value_schema + client._transport.list_google_ads_links ] = mock_rpc request = {} - client.update_sk_ad_network_conversion_value_schema(request) + client.list_google_ads_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_sk_ad_network_conversion_value_schema(request) + client.list_google_ads_links(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_sk_ad_network_conversion_value_schema_rest_required_fields( - request_type=analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest, +def test_list_google_ads_links_rest_required_fields( + request_type=analytics_admin.ListGoogleAdsLinksRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -61854,23 +61978,28 @@ def test_update_sk_ad_network_conversion_value_schema_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).list_google_ads_links._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_sk_ad_network_conversion_value_schema._get_unset_required_fields( - jsonified_request - ) + ).list_google_ads_links._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( + ( + "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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -61879,7 +62008,7 @@ def test_update_sk_ad_network_conversion_value_schema_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.SKAdNetworkConversionValueSchema() + return_value = analytics_admin.ListGoogleAdsLinksResponse() # 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 @@ -61891,50 +62020,47 @@ def test_update_sk_ad_network_conversion_value_schema_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 = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = analytics_admin.ListGoogleAdsLinksResponse.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_sk_ad_network_conversion_value_schema(request) + response = client.list_google_ads_links(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): +def test_list_google_ads_links_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_sk_ad_network_conversion_value_schema._get_unset_required_fields( - {} - ) + unset_fields = transport.list_google_ads_links._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) - & set( + set( ( - "skadnetworkConversionValueSchema", - "updateMask", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_update_sk_ad_network_conversion_value_schema_rest_flattened(): +def test_list_google_ads_links_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -61943,21 +62069,14 @@ def test_update_sk_ad_network_conversion_value_schema_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.SKAdNetworkConversionValueSchema() + return_value = analytics_admin.ListGoogleAdsLinksResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "skadnetwork_conversion_value_schema": { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", ) mock_args.update(sample_request) @@ -61965,28 +62084,25 @@ def test_update_sk_ad_network_conversion_value_schema_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = analytics_admin.ListGoogleAdsLinksResponse.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.update_sk_ad_network_conversion_value_schema(**mock_args) + client.list_google_ads_links(**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/{skadnetwork_conversion_value_schema.name=properties/*/dataStreams/*/sKAdNetworkConversionValueSchema/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/googleAdsLinks" % client.transport._host, args[1], ) -def test_update_sk_ad_network_conversion_value_schema_rest_flattened_error( - transport: str = "rest", -): +def test_list_google_ads_links_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -61995,16 +62111,76 @@ def test_update_sk_ad_network_conversion_value_schema_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_sk_ad_network_conversion_value_schema( - analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest(), - skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( - name="name_value" + client.list_google_ads_links( + analytics_admin.ListGoogleAdsLinksRequest(), + parent="parent_value", + ) + + +def test_list_google_ads_links_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListGoogleAdsLinksResponse( + google_ads_links=[ + resources.GoogleAdsLink(), + resources.GoogleAdsLink(), + resources.GoogleAdsLink(), + ], + next_page_token="abc", ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + analytics_admin.ListGoogleAdsLinksResponse( + google_ads_links=[], + next_page_token="def", + ), + analytics_admin.ListGoogleAdsLinksResponse( + google_ads_links=[ + resources.GoogleAdsLink(), + ], + next_page_token="ghi", + ), + analytics_admin.ListGoogleAdsLinksResponse( + google_ads_links=[ + resources.GoogleAdsLink(), + resources.GoogleAdsLink(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListGoogleAdsLinksResponse.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": "properties/sample1"} -def test_list_sk_ad_network_conversion_value_schemas_rest_use_cached_wrapped_rpc(): + pager = client.list_google_ads_links(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.GoogleAdsLink) for i in results) + + pages = list(client.list_google_ads_links(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_data_sharing_settings_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: @@ -62019,7 +62195,7 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_use_cached_wrapped_rpc # Ensure method has been cached assert ( - client._transport.list_sk_ad_network_conversion_value_schemas + client._transport.get_data_sharing_settings in client._transport._wrapped_methods ) @@ -62029,29 +62205,29 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_use_cached_wrapped_rpc "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_sk_ad_network_conversion_value_schemas + client._transport.get_data_sharing_settings ] = mock_rpc request = {} - client.list_sk_ad_network_conversion_value_schemas(request) + client.get_data_sharing_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_sk_ad_network_conversion_value_schemas(request) + client.get_data_sharing_settings(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_sk_ad_network_conversion_value_schemas_rest_required_fields( - request_type=analytics_admin.ListSKAdNetworkConversionValueSchemasRequest, +def test_get_data_sharing_settings_rest_required_fields( + request_type=analytics_admin.GetDataSharingSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -62062,32 +62238,21 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_sk_ad_network_conversion_value_schemas._get_unset_required_fields( - jsonified_request - ) + ).get_data_sharing_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_sk_ad_network_conversion_value_schemas._get_unset_required_fields( - jsonified_request - ) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).get_data_sharing_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -62096,7 +62261,7 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() + return_value = resources.DataSharingSettings() # 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 @@ -62117,44 +62282,30 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = ( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.pb( - return_value - ) - ) + return_value = resources.DataSharingSettings.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_sk_ad_network_conversion_value_schemas(request) + response = client.get_data_sharing_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_sk_ad_network_conversion_value_schemas_rest_unset_required_fields(): +def test_get_data_sharing_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_sk_ad_network_conversion_value_schemas._get_unset_required_fields( - {} - ) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.get_data_sharing_settings._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_sk_ad_network_conversion_value_schemas_rest_flattened(): +def test_get_data_sharing_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -62163,14 +62314,14 @@ def test_list_sk_ad_network_conversion_value_schemas_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 = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() + return_value = resources.DataSharingSettings() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = {"name": "accounts/sample1/dataSharingSettings"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) @@ -62178,30 +62329,25 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.pb( - return_value - ) + return_value = resources.DataSharingSettings.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_sk_ad_network_conversion_value_schemas(**mock_args) + client.get_data_sharing_settings(**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=properties/*/dataStreams/*}/sKAdNetworkConversionValueSchema" - % client.transport._host, + "%s/v1alpha/{name=accounts/*/dataSharingSettings}" % client.transport._host, args[1], ) -def test_list_sk_ad_network_conversion_value_schemas_rest_flattened_error( - transport: str = "rest", -): +def test_get_data_sharing_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -62210,87 +62356,13 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_sk_ad_network_conversion_value_schemas( - analytics_admin.ListSKAdNetworkConversionValueSchemasRequest(), - parent="parent_value", - ) - - -def test_list_sk_ad_network_conversion_value_schemas_rest_pager( - transport: str = "rest", -): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( - skadnetwork_conversion_value_schemas=[ - resources.SKAdNetworkConversionValueSchema(), - resources.SKAdNetworkConversionValueSchema(), - resources.SKAdNetworkConversionValueSchema(), - ], - next_page_token="abc", - ), - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( - skadnetwork_conversion_value_schemas=[], - next_page_token="def", - ), - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( - skadnetwork_conversion_value_schemas=[ - resources.SKAdNetworkConversionValueSchema(), - ], - next_page_token="ghi", - ), - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( - skadnetwork_conversion_value_schemas=[ - resources.SKAdNetworkConversionValueSchema(), - resources.SKAdNetworkConversionValueSchema(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.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": "properties/sample1/dataStreams/sample2"} - - pager = client.list_sk_ad_network_conversion_value_schemas( - request=sample_request - ) - - results = list(pager) - assert len(results) == 6 - assert all( - isinstance(i, resources.SKAdNetworkConversionValueSchema) for i in results - ) - - pages = list( - client.list_sk_ad_network_conversion_value_schemas( - request=sample_request - ).pages + client.get_data_sharing_settings( + analytics_admin.GetDataSharingSettingsRequest(), + name="name_value", ) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_search_change_history_events_rest_use_cached_wrapped_rpc(): +def test_get_measurement_protocol_secret_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: @@ -62305,7 +62377,7 @@ def test_search_change_history_events_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.search_change_history_events + client._transport.get_measurement_protocol_secret in client._transport._wrapped_methods ) @@ -62315,29 +62387,29 @@ def test_search_change_history_events_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.search_change_history_events + client._transport.get_measurement_protocol_secret ] = mock_rpc request = {} - client.search_change_history_events(request) + client.get_measurement_protocol_secret(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.search_change_history_events(request) + client.get_measurement_protocol_secret(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_search_change_history_events_rest_required_fields( - request_type=analytics_admin.SearchChangeHistoryEventsRequest, +def test_get_measurement_protocol_secret_rest_required_fields( + request_type=analytics_admin.GetMeasurementProtocolSecretRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["account"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -62348,21 +62420,21 @@ def test_search_change_history_events_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).search_change_history_events._get_unset_required_fields(jsonified_request) + ).get_measurement_protocol_secret._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["account"] = "account_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).search_change_history_events._get_unset_required_fields(jsonified_request) + ).get_measurement_protocol_secret._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "account" in jsonified_request - assert jsonified_request["account"] == "account_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -62371,7 +62443,7 @@ def test_search_change_history_events_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.SearchChangeHistoryEventsResponse() + return_value = resources.MeasurementProtocolSecret() # 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 @@ -62383,106 +62455,101 @@ def test_search_change_history_events_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.SearchChangeHistoryEventsResponse.pb( - return_value - ) + return_value = resources.MeasurementProtocolSecret.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.search_change_history_events(request) + response = client.get_measurement_protocol_secret(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_search_change_history_events_rest_unset_required_fields(): +def test_get_measurement_protocol_secret_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.search_change_history_events._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("account",))) + unset_fields = transport.get_measurement_protocol_secret._get_unset_required_fields( + {} + ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_search_change_history_events_rest_pager(transport: str = "rest"): +def test_get_measurement_protocol_secret_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="rest", ) # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - analytics_admin.SearchChangeHistoryEventsResponse( - change_history_events=[ - resources.ChangeHistoryEvent(), - resources.ChangeHistoryEvent(), - resources.ChangeHistoryEvent(), - ], - next_page_token="abc", - ), - analytics_admin.SearchChangeHistoryEventsResponse( - change_history_events=[], - next_page_token="def", - ), - analytics_admin.SearchChangeHistoryEventsResponse( - change_history_events=[ - resources.ChangeHistoryEvent(), - ], - next_page_token="ghi", - ), - analytics_admin.SearchChangeHistoryEventsResponse( - change_history_events=[ - resources.ChangeHistoryEvent(), - resources.ChangeHistoryEvent(), - ], - ), - ) - # Two responses for two calls - response = response + response + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = resources.MeasurementProtocolSecret() - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.SearchChangeHistoryEventsResponse.to_json(x) - for x in response + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", ) - 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 + mock_args.update(sample_request) - sample_request = {"account": "accounts/sample1"} + # 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.MeasurementProtocolSecret.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"} - pager = client.search_change_history_events(request=sample_request) + client.get_measurement_protocol_secret(**mock_args) - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.ChangeHistoryEvent) for i in results) + # 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=properties/*/dataStreams/*/measurementProtocolSecrets/*}" + % client.transport._host, + args[1], + ) - pages = list(client.search_change_history_events(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +def test_get_measurement_protocol_secret_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) -def test_get_google_signals_settings_rest_use_cached_wrapped_rpc(): + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_measurement_protocol_secret( + analytics_admin.GetMeasurementProtocolSecretRequest(), + name="name_value", + ) + + +def test_list_measurement_protocol_secrets_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: @@ -62497,7 +62564,7 @@ def test_get_google_signals_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_google_signals_settings + client._transport.list_measurement_protocol_secrets in client._transport._wrapped_methods ) @@ -62507,29 +62574,29 @@ def test_get_google_signals_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_google_signals_settings + client._transport.list_measurement_protocol_secrets ] = mock_rpc request = {} - client.get_google_signals_settings(request) + client.list_measurement_protocol_secrets(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_google_signals_settings(request) + client.list_measurement_protocol_secrets(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_google_signals_settings_rest_required_fields( - request_type=analytics_admin.GetGoogleSignalsSettingsRequest, +def test_list_measurement_protocol_secrets_rest_required_fields( + request_type=analytics_admin.ListMeasurementProtocolSecretsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -62540,21 +62607,28 @@ def test_get_google_signals_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_google_signals_settings._get_unset_required_fields(jsonified_request) + ).list_measurement_protocol_secrets._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_google_signals_settings._get_unset_required_fields(jsonified_request) + ).list_measurement_protocol_secrets._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -62563,7 +62637,7 @@ def test_get_google_signals_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.GoogleSignalsSettings() + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() # 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 @@ -62584,30 +62658,42 @@ def test_get_google_signals_settings_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleSignalsSettings.pb(return_value) + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse.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_google_signals_settings(request) + response = client.list_measurement_protocol_secrets(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_google_signals_settings_rest_unset_required_fields(): +def test_list_measurement_protocol_secrets_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_google_signals_settings._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = ( + transport.list_measurement_protocol_secrets._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_get_google_signals_settings_rest_flattened(): +def test_list_measurement_protocol_secrets_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -62616,14 +62702,14 @@ def test_get_google_signals_settings_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.GoogleSignalsSettings() + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/googleSignalsSettings"} + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -62631,26 +62717,30 @@ def test_get_google_signals_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleSignalsSettings.pb(return_value) + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse.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_google_signals_settings(**mock_args) + client.list_measurement_protocol_secrets(**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=properties/*/googleSignalsSettings}" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/measurementProtocolSecrets" % client.transport._host, args[1], ) -def test_get_google_signals_settings_rest_flattened_error(transport: str = "rest"): +def test_list_measurement_protocol_secrets_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -62659,13 +62749,79 @@ def test_get_google_signals_settings_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_google_signals_settings( - analytics_admin.GetGoogleSignalsSettingsRequest(), - name="name_value", + client.list_measurement_protocol_secrets( + analytics_admin.ListMeasurementProtocolSecretsRequest(), + parent="parent_value", ) -def test_update_google_signals_settings_rest_use_cached_wrapped_rpc(): +def test_list_measurement_protocol_secrets_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListMeasurementProtocolSecretsResponse( + measurement_protocol_secrets=[ + resources.MeasurementProtocolSecret(), + resources.MeasurementProtocolSecret(), + resources.MeasurementProtocolSecret(), + ], + next_page_token="abc", + ), + analytics_admin.ListMeasurementProtocolSecretsResponse( + measurement_protocol_secrets=[], + next_page_token="def", + ), + analytics_admin.ListMeasurementProtocolSecretsResponse( + measurement_protocol_secrets=[ + resources.MeasurementProtocolSecret(), + ], + next_page_token="ghi", + ), + analytics_admin.ListMeasurementProtocolSecretsResponse( + measurement_protocol_secrets=[ + resources.MeasurementProtocolSecret(), + resources.MeasurementProtocolSecret(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListMeasurementProtocolSecretsResponse.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": "properties/sample1/dataStreams/sample2"} + + pager = client.list_measurement_protocol_secrets(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.MeasurementProtocolSecret) for i in results) + + pages = list( + client.list_measurement_protocol_secrets(request=sample_request).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_measurement_protocol_secret_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: @@ -62680,7 +62836,7 @@ def test_update_google_signals_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_google_signals_settings + client._transport.create_measurement_protocol_secret in client._transport._wrapped_methods ) @@ -62690,28 +62846,29 @@ def test_update_google_signals_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_google_signals_settings + client._transport.create_measurement_protocol_secret ] = mock_rpc request = {} - client.update_google_signals_settings(request) + client.create_measurement_protocol_secret(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_google_signals_settings(request) + client.create_measurement_protocol_secret(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_google_signals_settings_rest_required_fields( - request_type=analytics_admin.UpdateGoogleSignalsSettingsRequest, +def test_create_measurement_protocol_secret_rest_required_fields( + request_type=analytics_admin.CreateMeasurementProtocolSecretRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -62722,19 +62879,21 @@ def test_update_google_signals_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_google_signals_settings._get_unset_required_fields(jsonified_request) + ).create_measurement_protocol_secret._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_google_signals_settings._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).create_measurement_protocol_secret._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -62743,7 +62902,7 @@ def test_update_google_signals_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.GoogleSignalsSettings() + return_value = resources.MeasurementProtocolSecret() # 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 @@ -62755,7 +62914,7 @@ def test_update_google_signals_settings_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "post", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -62765,40 +62924,40 @@ def test_update_google_signals_settings_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleSignalsSettings.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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_google_signals_settings(request) + response = client.create_measurement_protocol_secret(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_google_signals_settings_rest_unset_required_fields(): +def test_create_measurement_protocol_secret_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_google_signals_settings._get_unset_required_fields( - {} + unset_fields = ( + transport.create_measurement_protocol_secret._get_unset_required_fields({}) ) assert set(unset_fields) == ( - set(("updateMask",)) + set(()) & set( ( - "googleSignalsSettings", - "updateMask", + "parent", + "measurementProtocolSecret", ) ) ) -def test_update_google_signals_settings_rest_flattened(): +def test_create_measurement_protocol_secret_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -62807,19 +62966,17 @@ def test_update_google_signals_settings_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.GoogleSignalsSettings() + return_value = resources.MeasurementProtocolSecret() # get arguments that satisfy an http rule for this method - sample_request = { - "google_signals_settings": { - "name": "properties/sample1/googleSignalsSettings" - } - } + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - google_signals_settings=resources.GoogleSignalsSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", + measurement_protocol_secret=resources.MeasurementProtocolSecret( + name="name_value" + ), ) mock_args.update(sample_request) @@ -62827,26 +62984,28 @@ def test_update_google_signals_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleSignalsSettings.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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.update_google_signals_settings(**mock_args) + client.create_measurement_protocol_secret(**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/{google_signals_settings.name=properties/*/googleSignalsSettings}" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/measurementProtocolSecrets" % client.transport._host, args[1], ) -def test_update_google_signals_settings_rest_flattened_error(transport: str = "rest"): +def test_create_measurement_protocol_secret_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -62855,14 +63014,16 @@ def test_update_google_signals_settings_rest_flattened_error(transport: str = "r # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_google_signals_settings( - analytics_admin.UpdateGoogleSignalsSettingsRequest(), - google_signals_settings=resources.GoogleSignalsSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.create_measurement_protocol_secret( + analytics_admin.CreateMeasurementProtocolSecretRequest(), + parent="parent_value", + measurement_protocol_secret=resources.MeasurementProtocolSecret( + name="name_value" + ), ) -def test_create_conversion_event_rest_use_cached_wrapped_rpc(): +def test_delete_measurement_protocol_secret_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: @@ -62877,7 +63038,7 @@ def test_create_conversion_event_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_conversion_event + client._transport.delete_measurement_protocol_secret in client._transport._wrapped_methods ) @@ -62887,29 +63048,29 @@ def test_create_conversion_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_conversion_event + client._transport.delete_measurement_protocol_secret ] = mock_rpc request = {} - client.create_conversion_event(request) + client.delete_measurement_protocol_secret(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_conversion_event(request) + client.delete_measurement_protocol_secret(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_conversion_event_rest_required_fields( - request_type=analytics_admin.CreateConversionEventRequest, +def test_delete_measurement_protocol_secret_rest_required_fields( + request_type=analytics_admin.DeleteMeasurementProtocolSecretRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -62920,21 +63081,21 @@ def test_create_conversion_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_conversion_event._get_unset_required_fields(jsonified_request) + ).delete_measurement_protocol_secret._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_conversion_event._get_unset_required_fields(jsonified_request) + ).delete_measurement_protocol_secret._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -62943,7 +63104,7 @@ def test_create_conversion_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.ConversionEvent() + 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 @@ -62955,48 +63116,38 @@ def test_create_conversion_event_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = resources.ConversionEvent.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"} - response = client.create_conversion_event(request) + response = client.delete_measurement_protocol_secret(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_conversion_event_rest_unset_required_fields(): +def test_delete_measurement_protocol_secret_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_conversion_event._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "conversionEvent", - "parent", - ) - ) + unset_fields = ( + transport.delete_measurement_protocol_secret._get_unset_required_fields({}) ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_conversion_event_rest_flattened(): +def test_delete_measurement_protocol_secret_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -63005,42 +63156,43 @@ def test_create_conversion_event_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.ConversionEvent() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - conversion_event=resources.ConversionEvent(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.ConversionEvent.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_conversion_event(**mock_args) + client.delete_measurement_protocol_secret(**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=properties/*}/conversionEvents" + "%s/v1alpha/{name=properties/*/dataStreams/*/measurementProtocolSecrets/*}" % client.transport._host, args[1], ) -def test_create_conversion_event_rest_flattened_error(transport: str = "rest"): +def test_delete_measurement_protocol_secret_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -63049,14 +63201,13 @@ def test_create_conversion_event_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_conversion_event( - analytics_admin.CreateConversionEventRequest(), - parent="parent_value", - conversion_event=resources.ConversionEvent(name="name_value"), + client.delete_measurement_protocol_secret( + analytics_admin.DeleteMeasurementProtocolSecretRequest(), + name="name_value", ) -def test_update_conversion_event_rest_use_cached_wrapped_rpc(): +def test_update_measurement_protocol_secret_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: @@ -63071,7 +63222,7 @@ def test_update_conversion_event_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_conversion_event + client._transport.update_measurement_protocol_secret in client._transport._wrapped_methods ) @@ -63081,24 +63232,24 @@ def test_update_conversion_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_conversion_event + client._transport.update_measurement_protocol_secret ] = mock_rpc request = {} - client.update_conversion_event(request) + client.update_measurement_protocol_secret(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_conversion_event(request) + client.update_measurement_protocol_secret(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_conversion_event_rest_required_fields( - request_type=analytics_admin.UpdateConversionEventRequest, +def test_update_measurement_protocol_secret_rest_required_fields( + request_type=analytics_admin.UpdateMeasurementProtocolSecretRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -63113,14 +63264,14 @@ def test_update_conversion_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_conversion_event._get_unset_required_fields(jsonified_request) + ).update_measurement_protocol_secret._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_conversion_event._get_unset_required_fields(jsonified_request) + ).update_measurement_protocol_secret._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) @@ -63134,7 +63285,7 @@ def test_update_conversion_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.ConversionEvent() + return_value = resources.MeasurementProtocolSecret() # 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 @@ -63156,38 +63307,40 @@ def test_update_conversion_event_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.ConversionEvent.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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_conversion_event(request) + response = client.update_measurement_protocol_secret(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_conversion_event_rest_unset_required_fields(): +def test_update_measurement_protocol_secret_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_conversion_event._get_unset_required_fields({}) + unset_fields = ( + transport.update_measurement_protocol_secret._get_unset_required_fields({}) + ) assert set(unset_fields) == ( set(("updateMask",)) & set( ( - "conversionEvent", + "measurementProtocolSecret", "updateMask", ) ) ) -def test_update_conversion_event_rest_flattened(): +def test_update_measurement_protocol_secret_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -63196,16 +63349,20 @@ def test_update_conversion_event_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.ConversionEvent() + return_value = resources.MeasurementProtocolSecret() # get arguments that satisfy an http rule for this method sample_request = { - "conversion_event": {"name": "properties/sample1/conversionEvents/sample2"} + "measurement_protocol_secret": { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } } # get truthy value for each flattened field mock_args = dict( - conversion_event=resources.ConversionEvent(name="name_value"), + measurement_protocol_secret=resources.MeasurementProtocolSecret( + name="name_value" + ), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -63214,26 +63371,28 @@ def test_update_conversion_event_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.ConversionEvent.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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.update_conversion_event(**mock_args) + client.update_measurement_protocol_secret(**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/{conversion_event.name=properties/*/conversionEvents/*}" + "%s/v1alpha/{measurement_protocol_secret.name=properties/*/dataStreams/*/measurementProtocolSecrets/*}" % client.transport._host, args[1], ) -def test_update_conversion_event_rest_flattened_error(transport: str = "rest"): +def test_update_measurement_protocol_secret_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -63242,14 +63401,16 @@ def test_update_conversion_event_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_conversion_event( - analytics_admin.UpdateConversionEventRequest(), - conversion_event=resources.ConversionEvent(name="name_value"), + client.update_measurement_protocol_secret( + analytics_admin.UpdateMeasurementProtocolSecretRequest(), + measurement_protocol_secret=resources.MeasurementProtocolSecret( + name="name_value" + ), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_conversion_event_rest_use_cached_wrapped_rpc(): +def test_acknowledge_user_data_collection_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: @@ -63264,7 +63425,8 @@ def test_get_conversion_event_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_conversion_event in client._transport._wrapped_methods + client._transport.acknowledge_user_data_collection + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -63273,29 +63435,30 @@ def test_get_conversion_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_conversion_event + client._transport.acknowledge_user_data_collection ] = mock_rpc request = {} - client.get_conversion_event(request) + client.acknowledge_user_data_collection(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_conversion_event(request) + client.acknowledge_user_data_collection(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_conversion_event_rest_required_fields( - request_type=analytics_admin.GetConversionEventRequest, +def test_acknowledge_user_data_collection_rest_required_fields( + request_type=analytics_admin.AcknowledgeUserDataCollectionRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["property"] = "" + request_init["acknowledgement"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -63306,21 +63469,24 @@ def test_get_conversion_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_conversion_event._get_unset_required_fields(jsonified_request) + ).acknowledge_user_data_collection._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["property"] = "property_value" + jsonified_request["acknowledgement"] = "acknowledgement_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_conversion_event._get_unset_required_fields(jsonified_request) + ).acknowledge_user_data_collection._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 "property" in jsonified_request + assert jsonified_request["property"] == "property_value" + assert "acknowledgement" in jsonified_request + assert jsonified_request["acknowledgement"] == "acknowledgement_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -63329,7 +63495,7 @@ def test_get_conversion_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.ConversionEvent() + return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() # 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 @@ -63341,97 +63507,52 @@ def test_get_conversion_event_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.ConversionEvent.pb(return_value) + return_value = analytics_admin.AcknowledgeUserDataCollectionResponse.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_conversion_event(request) + response = client.acknowledge_user_data_collection(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_conversion_event_rest_unset_required_fields(): +def test_acknowledge_user_data_collection_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_conversion_event._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_get_conversion_event_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + unset_fields = ( + transport.acknowledge_user_data_collection._get_unset_required_fields({}) ) - - # 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.ConversionEvent() - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/conversionEvents/sample2"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.ConversionEvent.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_conversion_event(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1alpha/{name=properties/*/conversionEvents/*}" - % client.transport._host, - args[1], + assert set(unset_fields) == ( + set(()) + & set( + ( + "property", + "acknowledgement", + ) ) - - -def test_get_conversion_event_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_conversion_event( - analytics_admin.GetConversionEventRequest(), - name="name_value", - ) - -def test_delete_conversion_event_rest_use_cached_wrapped_rpc(): +def test_get_sk_ad_network_conversion_value_schema_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: @@ -63446,7 +63567,7 @@ def test_delete_conversion_event_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_conversion_event + client._transport.get_sk_ad_network_conversion_value_schema in client._transport._wrapped_methods ) @@ -63456,24 +63577,24 @@ def test_delete_conversion_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_conversion_event + client._transport.get_sk_ad_network_conversion_value_schema ] = mock_rpc request = {} - client.delete_conversion_event(request) + client.get_sk_ad_network_conversion_value_schema(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_conversion_event(request) + client.get_sk_ad_network_conversion_value_schema(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_conversion_event_rest_required_fields( - request_type=analytics_admin.DeleteConversionEventRequest, +def test_get_sk_ad_network_conversion_value_schema_rest_required_fields( + request_type=analytics_admin.GetSKAdNetworkConversionValueSchemaRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -63489,7 +63610,9 @@ def test_delete_conversion_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_conversion_event._get_unset_required_fields(jsonified_request) + ).get_sk_ad_network_conversion_value_schema._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -63498,7 +63621,9 @@ def test_delete_conversion_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_conversion_event._get_unset_required_fields(jsonified_request) + ).get_sk_ad_network_conversion_value_schema._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -63512,7 +63637,7 @@ def test_delete_conversion_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.SKAdNetworkConversionValueSchema() # 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 @@ -63524,36 +63649,43 @@ def test_delete_conversion_event_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.SKAdNetworkConversionValueSchema.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_conversion_event(request) + response = client.get_sk_ad_network_conversion_value_schema(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_conversion_event_rest_unset_required_fields(): +def test_get_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_conversion_event._get_unset_required_fields({}) + unset_fields = ( + transport.get_sk_ad_network_conversion_value_schema._get_unset_required_fields( + {} + ) + ) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_conversion_event_rest_flattened(): +def test_get_sk_ad_network_conversion_value_schema_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -63562,10 +63694,12 @@ def test_delete_conversion_event_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 = resources.SKAdNetworkConversionValueSchema() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/conversionEvents/sample2"} + sample_request = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } # get truthy value for each flattened field mock_args = dict( @@ -63576,25 +63710,29 @@ def test_delete_conversion_event_rest_flattened(): # 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 = resources.SKAdNetworkConversionValueSchema.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_conversion_event(**mock_args) + client.get_sk_ad_network_conversion_value_schema(**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=properties/*/conversionEvents/*}" + "%s/v1alpha/{name=properties/*/dataStreams/*/sKAdNetworkConversionValueSchema/*}" % client.transport._host, args[1], ) -def test_delete_conversion_event_rest_flattened_error(transport: str = "rest"): +def test_get_sk_ad_network_conversion_value_schema_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -63603,13 +63741,13 @@ def test_delete_conversion_event_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_conversion_event( - analytics_admin.DeleteConversionEventRequest(), + client.get_sk_ad_network_conversion_value_schema( + analytics_admin.GetSKAdNetworkConversionValueSchemaRequest(), name="name_value", ) -def test_list_conversion_events_rest_use_cached_wrapped_rpc(): +def test_create_sk_ad_network_conversion_value_schema_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: @@ -63624,7 +63762,7 @@ def test_list_conversion_events_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_conversion_events + client._transport.create_sk_ad_network_conversion_value_schema in client._transport._wrapped_methods ) @@ -63634,24 +63772,24 @@ def test_list_conversion_events_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_conversion_events + client._transport.create_sk_ad_network_conversion_value_schema ] = mock_rpc request = {} - client.list_conversion_events(request) + client.create_sk_ad_network_conversion_value_schema(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_conversion_events(request) + client.create_sk_ad_network_conversion_value_schema(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_conversion_events_rest_required_fields( - request_type=analytics_admin.ListConversionEventsRequest, +def test_create_sk_ad_network_conversion_value_schema_rest_required_fields( + request_type=analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -63667,7 +63805,9 @@ def test_list_conversion_events_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_conversion_events._get_unset_required_fields(jsonified_request) + ).create_sk_ad_network_conversion_value_schema._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -63676,13 +63816,8 @@ def test_list_conversion_events_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_conversion_events._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) + ).create_sk_ad_network_conversion_value_schema._get_unset_required_fields( + jsonified_request ) jsonified_request.update(unset_fields) @@ -63697,7 +63832,7 @@ def test_list_conversion_events_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListConversionEventsResponse() + return_value = resources.SKAdNetworkConversionValueSchema() # 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 @@ -63709,47 +63844,50 @@ def test_list_conversion_events_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 = analytics_admin.ListConversionEventsResponse.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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_conversion_events(request) + response = client.create_sk_ad_network_conversion_value_schema(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_conversion_events_rest_unset_required_fields(): +def test_create_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_conversion_events._get_unset_required_fields({}) + unset_fields = transport.create_sk_ad_network_conversion_value_schema._get_unset_required_fields( + {} + ) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "pageSize", - "pageToken", + "parent", + "skadnetworkConversionValueSchema", ) ) - & set(("parent",)) ) -def test_list_conversion_events_rest_flattened(): +def test_create_sk_ad_network_conversion_value_schema_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -63758,14 +63896,17 @@ def test_list_conversion_events_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 = analytics_admin.ListConversionEventsResponse() + return_value = resources.SKAdNetworkConversionValueSchema() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( parent="parent_value", + skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( + name="name_value" + ), ) mock_args.update(sample_request) @@ -63773,26 +63914,28 @@ def test_list_conversion_events_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListConversionEventsResponse.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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_conversion_events(**mock_args) + client.create_sk_ad_network_conversion_value_schema(**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=properties/*}/conversionEvents" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/sKAdNetworkConversionValueSchema" % client.transport._host, args[1], ) -def test_list_conversion_events_rest_flattened_error(transport: str = "rest"): +def test_create_sk_ad_network_conversion_value_schema_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -63801,76 +63944,16 @@ def test_list_conversion_events_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_conversion_events( - analytics_admin.ListConversionEventsRequest(), + client.create_sk_ad_network_conversion_value_schema( + analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest(), parent="parent_value", - ) - - -def test_list_conversion_events_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListConversionEventsResponse( - conversion_events=[ - resources.ConversionEvent(), - resources.ConversionEvent(), - resources.ConversionEvent(), - ], - next_page_token="abc", - ), - analytics_admin.ListConversionEventsResponse( - conversion_events=[], - next_page_token="def", - ), - analytics_admin.ListConversionEventsResponse( - conversion_events=[ - resources.ConversionEvent(), - ], - next_page_token="ghi", - ), - analytics_admin.ListConversionEventsResponse( - conversion_events=[ - resources.ConversionEvent(), - resources.ConversionEvent(), - ], + skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( + name="name_value" ), ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListConversionEventsResponse.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": "properties/sample1"} - - pager = client.list_conversion_events(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.ConversionEvent) for i in results) - - pages = list(client.list_conversion_events(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_create_key_event_rest_use_cached_wrapped_rpc(): +def test_delete_sk_ad_network_conversion_value_schema_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: @@ -63884,7 +63967,10 @@ def test_create_key_event_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_key_event in client._transport._wrapped_methods + assert ( + client._transport.delete_sk_ad_network_conversion_value_schema + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -63892,29 +63978,29 @@ def test_create_key_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_key_event + client._transport.delete_sk_ad_network_conversion_value_schema ] = mock_rpc request = {} - client.create_key_event(request) + client.delete_sk_ad_network_conversion_value_schema(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_key_event(request) + client.delete_sk_ad_network_conversion_value_schema(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_key_event_rest_required_fields( - request_type=analytics_admin.CreateKeyEventRequest, +def test_delete_sk_ad_network_conversion_value_schema_rest_required_fields( + request_type=analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -63925,21 +64011,25 @@ def test_create_key_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_key_event._get_unset_required_fields(jsonified_request) + ).delete_sk_ad_network_conversion_value_schema._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_key_event._get_unset_required_fields(jsonified_request) + ).delete_sk_ad_network_conversion_value_schema._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -63948,7 +64038,7 @@ def test_create_key_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.KeyEvent() + 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 @@ -63960,48 +64050,38 @@ def test_create_key_event_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = resources.KeyEvent.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"} - response = client.create_key_event(request) + response = client.delete_sk_ad_network_conversion_value_schema(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_key_event_rest_unset_required_fields(): +def test_delete_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_key_event._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "keyEvent", - "parent", - ) - ) + unset_fields = transport.delete_sk_ad_network_conversion_value_schema._get_unset_required_fields( + {} ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_key_event_rest_flattened(): +def test_delete_sk_ad_network_conversion_value_schema_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -64010,41 +64090,43 @@ def test_create_key_event_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.KeyEvent() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - key_event=resources.KeyEvent(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.KeyEvent.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_key_event(**mock_args) + client.delete_sk_ad_network_conversion_value_schema(**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=properties/*}/keyEvents" % client.transport._host, + "%s/v1alpha/{name=properties/*/dataStreams/*/sKAdNetworkConversionValueSchema/*}" + % client.transport._host, args[1], ) -def test_create_key_event_rest_flattened_error(transport: str = "rest"): +def test_delete_sk_ad_network_conversion_value_schema_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -64053,14 +64135,13 @@ def test_create_key_event_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_key_event( - analytics_admin.CreateKeyEventRequest(), - parent="parent_value", - key_event=resources.KeyEvent(name="name_value"), + client.delete_sk_ad_network_conversion_value_schema( + analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest(), + name="name_value", ) -def test_update_key_event_rest_use_cached_wrapped_rpc(): +def test_update_sk_ad_network_conversion_value_schema_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: @@ -64074,7 +64155,10 @@ def test_update_key_event_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_key_event in client._transport._wrapped_methods + assert ( + client._transport.update_sk_ad_network_conversion_value_schema + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -64082,24 +64166,24 @@ def test_update_key_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_key_event + client._transport.update_sk_ad_network_conversion_value_schema ] = mock_rpc request = {} - client.update_key_event(request) + client.update_sk_ad_network_conversion_value_schema(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_key_event(request) + client.update_sk_ad_network_conversion_value_schema(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_key_event_rest_required_fields( - request_type=analytics_admin.UpdateKeyEventRequest, +def test_update_sk_ad_network_conversion_value_schema_rest_required_fields( + request_type=analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -64114,14 +64198,18 @@ def test_update_key_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_key_event._get_unset_required_fields(jsonified_request) + ).update_sk_ad_network_conversion_value_schema._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_key_event._get_unset_required_fields(jsonified_request) + ).update_sk_ad_network_conversion_value_schema._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) @@ -64135,7 +64223,7 @@ def test_update_key_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.KeyEvent() + return_value = resources.SKAdNetworkConversionValueSchema() # 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 @@ -64157,38 +64245,40 @@ def test_update_key_event_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.KeyEvent.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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_key_event(request) + response = client.update_sk_ad_network_conversion_value_schema(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_key_event_rest_unset_required_fields(): +def test_update_sk_ad_network_conversion_value_schema_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_key_event._get_unset_required_fields({}) + unset_fields = transport.update_sk_ad_network_conversion_value_schema._get_unset_required_fields( + {} + ) assert set(unset_fields) == ( set(("updateMask",)) & set( ( - "keyEvent", + "skadnetworkConversionValueSchema", "updateMask", ) ) ) -def test_update_key_event_rest_flattened(): +def test_update_sk_ad_network_conversion_value_schema_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -64197,14 +64287,20 @@ def test_update_key_event_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.KeyEvent() + return_value = resources.SKAdNetworkConversionValueSchema() # get arguments that satisfy an http rule for this method - sample_request = {"key_event": {"name": "properties/sample1/keyEvents/sample2"}} + sample_request = { + "skadnetwork_conversion_value_schema": { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } + } # get truthy value for each flattened field mock_args = dict( - key_event=resources.KeyEvent(name="name_value"), + skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( + name="name_value" + ), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -64213,26 +64309,28 @@ def test_update_key_event_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.KeyEvent.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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.update_key_event(**mock_args) + client.update_sk_ad_network_conversion_value_schema(**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/{key_event.name=properties/*/keyEvents/*}" + "%s/v1alpha/{skadnetwork_conversion_value_schema.name=properties/*/dataStreams/*/sKAdNetworkConversionValueSchema/*}" % client.transport._host, args[1], ) -def test_update_key_event_rest_flattened_error(transport: str = "rest"): +def test_update_sk_ad_network_conversion_value_schema_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -64241,14 +64339,16 @@ def test_update_key_event_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_key_event( - analytics_admin.UpdateKeyEventRequest(), - key_event=resources.KeyEvent(name="name_value"), + client.update_sk_ad_network_conversion_value_schema( + analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest(), + skadnetwork_conversion_value_schema=resources.SKAdNetworkConversionValueSchema( + name="name_value" + ), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_key_event_rest_use_cached_wrapped_rpc(): +def test_list_sk_ad_network_conversion_value_schemas_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: @@ -64262,35 +64362,40 @@ def test_get_key_event_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_key_event in client._transport._wrapped_methods + assert ( + client._transport.list_sk_ad_network_conversion_value_schemas + 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_key_event] = mock_rpc + client._transport._wrapped_methods[ + client._transport.list_sk_ad_network_conversion_value_schemas + ] = mock_rpc request = {} - client.get_key_event(request) + client.list_sk_ad_network_conversion_value_schemas(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_key_event(request) + client.list_sk_ad_network_conversion_value_schemas(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_key_event_rest_required_fields( - request_type=analytics_admin.GetKeyEventRequest, +def test_list_sk_ad_network_conversion_value_schemas_rest_required_fields( + request_type=analytics_admin.ListSKAdNetworkConversionValueSchemasRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -64301,21 +64406,32 @@ def test_get_key_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_key_event._get_unset_required_fields(jsonified_request) + ).list_sk_ad_network_conversion_value_schemas._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_key_event._get_unset_required_fields(jsonified_request) + ).list_sk_ad_network_conversion_value_schemas._get_unset_required_fields( + jsonified_request + ) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -64324,7 +64440,7 @@ def test_get_key_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.KeyEvent() + return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() # 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 @@ -64345,30 +64461,44 @@ def test_get_key_event_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.KeyEvent.pb(return_value) + return_value = ( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.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_key_event(request) + response = client.list_sk_ad_network_conversion_value_schemas(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_key_event_rest_unset_required_fields(): +def test_list_sk_ad_network_conversion_value_schemas_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_key_event._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.list_sk_ad_network_conversion_value_schemas._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_get_key_event_rest_flattened(): +def test_list_sk_ad_network_conversion_value_schemas_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -64377,14 +64507,14 @@ def test_get_key_event_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.KeyEvent() + return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/keyEvents/sample2"} + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -64392,25 +64522,30 @@ def test_get_key_event_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.KeyEvent.pb(return_value) + return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.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_key_event(**mock_args) + client.list_sk_ad_network_conversion_value_schemas(**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=properties/*/keyEvents/*}" % client.transport._host, + "%s/v1alpha/{parent=properties/*/dataStreams/*}/sKAdNetworkConversionValueSchema" + % client.transport._host, args[1], ) -def test_get_key_event_rest_flattened_error(transport: str = "rest"): +def test_list_sk_ad_network_conversion_value_schemas_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -64419,13 +64554,87 @@ def test_get_key_event_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_key_event( - analytics_admin.GetKeyEventRequest(), - name="name_value", + client.list_sk_ad_network_conversion_value_schemas( + analytics_admin.ListSKAdNetworkConversionValueSchemasRequest(), + parent="parent_value", ) -def test_delete_key_event_rest_use_cached_wrapped_rpc(): +def test_list_sk_ad_network_conversion_value_schemas_rest_pager( + transport: str = "rest", +): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( + skadnetwork_conversion_value_schemas=[ + resources.SKAdNetworkConversionValueSchema(), + resources.SKAdNetworkConversionValueSchema(), + resources.SKAdNetworkConversionValueSchema(), + ], + next_page_token="abc", + ), + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( + skadnetwork_conversion_value_schemas=[], + next_page_token="def", + ), + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( + skadnetwork_conversion_value_schemas=[ + resources.SKAdNetworkConversionValueSchema(), + ], + next_page_token="ghi", + ), + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( + skadnetwork_conversion_value_schemas=[ + resources.SKAdNetworkConversionValueSchema(), + resources.SKAdNetworkConversionValueSchema(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.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": "properties/sample1/dataStreams/sample2"} + + pager = client.list_sk_ad_network_conversion_value_schemas( + request=sample_request + ) + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, resources.SKAdNetworkConversionValueSchema) for i in results + ) + + pages = list( + client.list_sk_ad_network_conversion_value_schemas( + request=sample_request + ).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_search_change_history_events_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -64439,7 +64648,10 @@ def test_delete_key_event_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_key_event in client._transport._wrapped_methods + assert ( + client._transport.search_change_history_events + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -64447,29 +64659,29 @@ def test_delete_key_event_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_key_event + client._transport.search_change_history_events ] = mock_rpc request = {} - client.delete_key_event(request) + client.search_change_history_events(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_key_event(request) + client.search_change_history_events(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_key_event_rest_required_fields( - request_type=analytics_admin.DeleteKeyEventRequest, +def test_search_change_history_events_rest_required_fields( + request_type=analytics_admin.SearchChangeHistoryEventsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["account"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -64480,21 +64692,21 @@ def test_delete_key_event_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_key_event._get_unset_required_fields(jsonified_request) + ).search_change_history_events._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["account"] = "account_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_key_event._get_unset_required_fields(jsonified_request) + ).search_change_history_events._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 "account" in jsonified_request + assert jsonified_request["account"] == "account_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -64503,7 +64715,7 @@ def test_delete_key_event_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.SearchChangeHistoryEventsResponse() # 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 @@ -64515,91 +64727,106 @@ def test_delete_key_event_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 = analytics_admin.SearchChangeHistoryEventsResponse.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_key_event(request) + response = client.search_change_history_events(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_key_event_rest_unset_required_fields(): +def test_search_change_history_events_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_key_event._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.search_change_history_events._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("account",))) -def test_delete_key_event_rest_flattened(): +def test_search_change_history_events_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/keyEvents/sample2"} - - # get truthy value for each flattened field - mock_args = dict( - 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 = ( + analytics_admin.SearchChangeHistoryEventsResponse( + change_history_events=[ + resources.ChangeHistoryEvent(), + resources.ChangeHistoryEvent(), + resources.ChangeHistoryEvent(), + ], + next_page_token="abc", + ), + analytics_admin.SearchChangeHistoryEventsResponse( + change_history_events=[], + next_page_token="def", + ), + analytics_admin.SearchChangeHistoryEventsResponse( + change_history_events=[ + resources.ChangeHistoryEvent(), + ], + next_page_token="ghi", + ), + analytics_admin.SearchChangeHistoryEventsResponse( + change_history_events=[ + resources.ChangeHistoryEvent(), + resources.ChangeHistoryEvent(), + ], + ), ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - - client.delete_key_event(**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/v1alpha/{name=properties/*/keyEvents/*}" % client.transport._host, - args[1], + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.SearchChangeHistoryEventsResponse.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 = {"account": "accounts/sample1"} -def test_delete_key_event_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) + pager = client.search_change_history_events(request=sample_request) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.delete_key_event( - analytics_admin.DeleteKeyEventRequest(), - name="name_value", - ) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.ChangeHistoryEvent) for i in results) + + pages = list(client.search_change_history_events(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_list_key_events_rest_use_cached_wrapped_rpc(): +def test_get_google_signals_settings_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: @@ -64613,35 +64840,40 @@ def test_list_key_events_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_key_events in client._transport._wrapped_methods + assert ( + client._transport.get_google_signals_settings + 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_key_events] = mock_rpc + client._transport._wrapped_methods[ + client._transport.get_google_signals_settings + ] = mock_rpc request = {} - client.list_key_events(request) + client.get_google_signals_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_key_events(request) + client.get_google_signals_settings(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_key_events_rest_required_fields( - request_type=analytics_admin.ListKeyEventsRequest, +def test_get_google_signals_settings_rest_required_fields( + request_type=analytics_admin.GetGoogleSignalsSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -64652,28 +64884,21 @@ def test_list_key_events_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_key_events._get_unset_required_fields(jsonified_request) + ).get_google_signals_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_key_events._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).get_google_signals_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -64682,7 +64907,7 @@ def test_list_key_events_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListKeyEventsResponse() + return_value = resources.GoogleSignalsSettings() # 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 @@ -64703,38 +64928,30 @@ def test_list_key_events_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListKeyEventsResponse.pb(return_value) + return_value = resources.GoogleSignalsSettings.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_key_events(request) + response = client.get_google_signals_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_key_events_rest_unset_required_fields(): +def test_get_google_signals_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_key_events._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.get_google_signals_settings._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_key_events_rest_flattened(): +def test_get_google_signals_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -64743,14 +64960,14 @@ def test_list_key_events_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 = analytics_admin.ListKeyEventsResponse() + return_value = resources.GoogleSignalsSettings() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"name": "properties/sample1/googleSignalsSettings"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) @@ -64758,25 +64975,26 @@ def test_list_key_events_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListKeyEventsResponse.pb(return_value) + return_value = resources.GoogleSignalsSettings.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_key_events(**mock_args) + client.get_google_signals_settings(**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=properties/*}/keyEvents" % client.transport._host, + "%s/v1alpha/{name=properties/*/googleSignalsSettings}" + % client.transport._host, args[1], ) -def test_list_key_events_rest_flattened_error(transport: str = "rest"): +def test_get_google_signals_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -64785,76 +65003,13 @@ def test_list_key_events_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_key_events( - analytics_admin.ListKeyEventsRequest(), - parent="parent_value", - ) - - -def test_list_key_events_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListKeyEventsResponse( - key_events=[ - resources.KeyEvent(), - resources.KeyEvent(), - resources.KeyEvent(), - ], - next_page_token="abc", - ), - analytics_admin.ListKeyEventsResponse( - key_events=[], - next_page_token="def", - ), - analytics_admin.ListKeyEventsResponse( - key_events=[ - resources.KeyEvent(), - ], - next_page_token="ghi", - ), - analytics_admin.ListKeyEventsResponse( - key_events=[ - resources.KeyEvent(), - resources.KeyEvent(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListKeyEventsResponse.to_json(x) for x in response + client.get_google_signals_settings( + analytics_admin.GetGoogleSignalsSettingsRequest(), + name="name_value", ) - 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": "properties/sample1"} - - pager = client.list_key_events(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.KeyEvent) for i in results) - - pages = list(client.list_key_events(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_get_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): +def test_update_google_signals_settings_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: @@ -64869,7 +65024,7 @@ def test_get_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_display_video360_advertiser_link + client._transport.update_google_signals_settings in client._transport._wrapped_methods ) @@ -64879,29 +65034,28 @@ def test_get_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_display_video360_advertiser_link + client._transport.update_google_signals_settings ] = mock_rpc request = {} - client.get_display_video360_advertiser_link(request) + client.update_google_signals_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_display_video360_advertiser_link(request) + client.update_google_signals_settings(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_display_video360_advertiser_link_rest_required_fields( - request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, +def test_update_google_signals_settings_rest_required_fields( + request_type=analytics_admin.UpdateGoogleSignalsSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -64912,21 +65066,19 @@ def test_get_display_video360_advertiser_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_display_video360_advertiser_link._get_unset_required_fields(jsonified_request) + ).update_google_signals_settings._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_display_video360_advertiser_link._get_unset_required_fields(jsonified_request) + ).update_google_signals_settings._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -64935,7 +65087,7 @@ def test_get_display_video360_advertiser_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DisplayVideo360AdvertiserLink() + return_value = resources.GoogleSignalsSettings() # 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 @@ -64947,41 +65099,50 @@ def test_get_display_video360_advertiser_link_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 = resources.DisplayVideo360AdvertiserLink.pb(return_value) + return_value = resources.GoogleSignalsSettings.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_display_video360_advertiser_link(request) + response = client.update_google_signals_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_display_video360_advertiser_link_rest_unset_required_fields(): +def test_update_google_signals_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.get_display_video360_advertiser_link._get_unset_required_fields({}) + unset_fields = transport.update_google_signals_settings._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "googleSignalsSettings", + "updateMask", + ) + ) ) - assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_display_video360_advertiser_link_rest_flattened(): +def test_update_google_signals_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -64990,16 +65151,19 @@ def test_get_display_video360_advertiser_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.DisplayVideo360AdvertiserLink() + return_value = resources.GoogleSignalsSettings() # get arguments that satisfy an http rule for this method sample_request = { - "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" + "google_signals_settings": { + "name": "properties/sample1/googleSignalsSettings" + } } # get truthy value for each flattened field mock_args = dict( - name="name_value", + google_signals_settings=resources.GoogleSignalsSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -65007,28 +65171,26 @@ def test_get_display_video360_advertiser_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLink.pb(return_value) + return_value = resources.GoogleSignalsSettings.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_display_video360_advertiser_link(**mock_args) + client.update_google_signals_settings(**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=properties/*/displayVideo360AdvertiserLinks/*}" + "%s/v1alpha/{google_signals_settings.name=properties/*/googleSignalsSettings}" % client.transport._host, args[1], ) -def test_get_display_video360_advertiser_link_rest_flattened_error( - transport: str = "rest", -): +def test_update_google_signals_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -65037,13 +65199,14 @@ def test_get_display_video360_advertiser_link_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_display_video360_advertiser_link( - analytics_admin.GetDisplayVideo360AdvertiserLinkRequest(), - name="name_value", + client.update_google_signals_settings( + analytics_admin.UpdateGoogleSignalsSettingsRequest(), + google_signals_settings=resources.GoogleSignalsSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_list_display_video360_advertiser_links_rest_use_cached_wrapped_rpc(): +def test_create_conversion_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -65058,7 +65221,7 @@ def test_list_display_video360_advertiser_links_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_display_video360_advertiser_links + client._transport.create_conversion_event in client._transport._wrapped_methods ) @@ -65068,24 +65231,24 @@ def test_list_display_video360_advertiser_links_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_display_video360_advertiser_links + client._transport.create_conversion_event ] = mock_rpc request = {} - client.list_display_video360_advertiser_links(request) + client.create_conversion_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_display_video360_advertiser_links(request) + client.create_conversion_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_list_display_video360_advertiser_links_rest_required_fields( - request_type=analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, +def test_create_conversion_event_rest_required_fields( + request_type=analytics_admin.CreateConversionEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -65101,9 +65264,7 @@ def test_list_display_video360_advertiser_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_display_video360_advertiser_links._get_unset_required_fields( - jsonified_request - ) + ).create_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -65112,16 +65273,7 @@ def test_list_display_video360_advertiser_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_display_video360_advertiser_links._get_unset_required_fields( - jsonified_request - ) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).create_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -65135,7 +65287,7 @@ def test_list_display_video360_advertiser_links_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() + return_value = resources.ConversionEvent() # 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 @@ -65147,53 +65299,48 @@ def test_list_display_video360_advertiser_links_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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.pb( - return_value - ) - ) + return_value = resources.ConversionEvent.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_display_video360_advertiser_links(request) + response = client.create_conversion_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_display_video360_advertiser_links_rest_unset_required_fields(): +def test_create_conversion_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.list_display_video360_advertiser_links._get_unset_required_fields({}) - ) + unset_fields = transport.create_conversion_event._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "pageSize", - "pageToken", + "conversionEvent", + "parent", ) ) - & set(("parent",)) ) -def test_list_display_video360_advertiser_links_rest_flattened(): +def test_create_conversion_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -65202,7 +65349,7 @@ def test_list_display_video360_advertiser_links_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 = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() + return_value = resources.ConversionEvent() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -65210,6 +65357,7 @@ def test_list_display_video360_advertiser_links_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", + conversion_event=resources.ConversionEvent(name="name_value"), ) mock_args.update(sample_request) @@ -65217,30 +65365,26 @@ def test_list_display_video360_advertiser_links_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.pb( - return_value - ) + return_value = resources.ConversionEvent.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_display_video360_advertiser_links(**mock_args) + client.create_conversion_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinks" + "%s/v1alpha/{parent=properties/*}/conversionEvents" % client.transport._host, args[1], ) -def test_list_display_video360_advertiser_links_rest_flattened_error( - transport: str = "rest", -): +def test_create_conversion_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -65249,81 +65393,14 @@ def test_list_display_video360_advertiser_links_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_display_video360_advertiser_links( - analytics_admin.ListDisplayVideo360AdvertiserLinksRequest(), + client.create_conversion_event( + analytics_admin.CreateConversionEventRequest(), parent="parent_value", + conversion_event=resources.ConversionEvent(name="name_value"), ) -def test_list_display_video360_advertiser_links_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( - display_video_360_advertiser_links=[ - resources.DisplayVideo360AdvertiserLink(), - resources.DisplayVideo360AdvertiserLink(), - resources.DisplayVideo360AdvertiserLink(), - ], - next_page_token="abc", - ), - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( - display_video_360_advertiser_links=[], - next_page_token="def", - ), - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( - display_video_360_advertiser_links=[ - resources.DisplayVideo360AdvertiserLink(), - ], - next_page_token="ghi", - ), - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( - display_video_360_advertiser_links=[ - resources.DisplayVideo360AdvertiserLink(), - resources.DisplayVideo360AdvertiserLink(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.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": "properties/sample1"} - - pager = client.list_display_video360_advertiser_links(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all( - isinstance(i, resources.DisplayVideo360AdvertiserLink) for i in results - ) - - pages = list( - client.list_display_video360_advertiser_links(request=sample_request).pages - ) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_create_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): +def test_update_conversion_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -65338,7 +65415,7 @@ def test_create_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_display_video360_advertiser_link + client._transport.update_conversion_event in client._transport._wrapped_methods ) @@ -65348,29 +65425,28 @@ def test_create_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_display_video360_advertiser_link + client._transport.update_conversion_event ] = mock_rpc request = {} - client.create_display_video360_advertiser_link(request) + client.update_conversion_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_display_video360_advertiser_link(request) + client.update_conversion_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_display_video360_advertiser_link_rest_required_fields( - request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, +def test_update_conversion_event_rest_required_fields( + request_type=analytics_admin.UpdateConversionEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -65381,25 +65457,19 @@ def test_create_display_video360_advertiser_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_display_video360_advertiser_link._get_unset_required_fields( - jsonified_request - ) + ).update_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_display_video360_advertiser_link._get_unset_required_fields( - jsonified_request - ) + ).update_conversion_event._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -65408,7 +65478,7 @@ def test_create_display_video360_advertiser_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DisplayVideo360AdvertiserLink() + return_value = resources.ConversionEvent() # 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 @@ -65420,7 +65490,7 @@ def test_create_display_video360_advertiser_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -65430,40 +65500,38 @@ def test_create_display_video360_advertiser_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLink.pb(return_value) + return_value = resources.ConversionEvent.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.create_display_video360_advertiser_link(request) + response = client.update_conversion_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_display_video360_advertiser_link_rest_unset_required_fields(): +def test_update_conversion_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.create_display_video360_advertiser_link._get_unset_required_fields({}) - ) + unset_fields = transport.update_conversion_event._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) + set(("updateMask",)) & set( ( - "parent", - "displayVideo360AdvertiserLink", + "conversionEvent", + "updateMask", ) ) ) -def test_create_display_video360_advertiser_link_rest_flattened(): +def test_update_conversion_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -65472,17 +65540,17 @@ def test_create_display_video360_advertiser_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.DisplayVideo360AdvertiserLink() + return_value = resources.ConversionEvent() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "conversion_event": {"name": "properties/sample1/conversionEvents/sample2"} + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( - name="name_value" - ), + conversion_event=resources.ConversionEvent(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -65490,28 +65558,26 @@ def test_create_display_video360_advertiser_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLink.pb(return_value) + return_value = resources.ConversionEvent.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_display_video360_advertiser_link(**mock_args) + client.update_conversion_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinks" + "%s/v1alpha/{conversion_event.name=properties/*/conversionEvents/*}" % client.transport._host, args[1], ) -def test_create_display_video360_advertiser_link_rest_flattened_error( - transport: str = "rest", -): +def test_update_conversion_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -65520,16 +65586,14 @@ def test_create_display_video360_advertiser_link_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_display_video360_advertiser_link( - analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest(), - parent="parent_value", - display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( - name="name_value" - ), + client.update_conversion_event( + analytics_admin.UpdateConversionEventRequest(), + conversion_event=resources.ConversionEvent(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): +def test_get_conversion_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -65544,8 +65608,7 @@ def test_delete_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_display_video360_advertiser_link - in client._transport._wrapped_methods + client._transport.get_conversion_event in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -65554,24 +65617,24 @@ def test_delete_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_display_video360_advertiser_link + client._transport.get_conversion_event ] = mock_rpc request = {} - client.delete_display_video360_advertiser_link(request) + client.get_conversion_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_display_video360_advertiser_link(request) + client.get_conversion_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_display_video360_advertiser_link_rest_required_fields( - request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, +def test_get_conversion_event_rest_required_fields( + request_type=analytics_admin.GetConversionEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -65587,9 +65650,7 @@ def test_delete_display_video360_advertiser_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_display_video360_advertiser_link._get_unset_required_fields( - jsonified_request - ) + ).get_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -65598,9 +65659,7 @@ def test_delete_display_video360_advertiser_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_display_video360_advertiser_link._get_unset_required_fields( - jsonified_request - ) + ).get_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -65614,7 +65673,7 @@ def test_delete_display_video360_advertiser_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.ConversionEvent() # 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 @@ -65626,38 +65685,39 @@ def test_delete_display_video360_advertiser_link_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.ConversionEvent.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_display_video360_advertiser_link(request) + response = client.get_conversion_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_display_video360_advertiser_link_rest_unset_required_fields(): +def test_get_conversion_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.delete_display_video360_advertiser_link._get_unset_required_fields({}) - ) + unset_fields = transport.get_conversion_event._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_display_video360_advertiser_link_rest_flattened(): +def test_get_conversion_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -65666,12 +65726,10 @@ def test_delete_display_video360_advertiser_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 = resources.ConversionEvent() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" - } + sample_request = {"name": "properties/sample1/conversionEvents/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -65682,27 +65740,27 @@ def test_delete_display_video360_advertiser_link_rest_flattened(): # 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 = resources.ConversionEvent.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_display_video360_advertiser_link(**mock_args) + client.get_conversion_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinks/*}" + "%s/v1alpha/{name=properties/*/conversionEvents/*}" % client.transport._host, args[1], ) -def test_delete_display_video360_advertiser_link_rest_flattened_error( - transport: str = "rest", -): +def test_get_conversion_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -65711,13 +65769,13 @@ def test_delete_display_video360_advertiser_link_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_display_video360_advertiser_link( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest(), + client.get_conversion_event( + analytics_admin.GetConversionEventRequest(), name="name_value", ) -def test_update_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): +def test_delete_conversion_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -65732,7 +65790,7 @@ def test_update_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_display_video360_advertiser_link + client._transport.delete_conversion_event in client._transport._wrapped_methods ) @@ -65742,28 +65800,29 @@ def test_update_display_video360_advertiser_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_display_video360_advertiser_link + client._transport.delete_conversion_event ] = mock_rpc request = {} - client.update_display_video360_advertiser_link(request) + client.delete_conversion_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_display_video360_advertiser_link(request) + client.delete_conversion_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_display_video360_advertiser_link_rest_required_fields( - request_type=analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, +def test_delete_conversion_event_rest_required_fields( + request_type=analytics_admin.DeleteConversionEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -65774,23 +65833,21 @@ def test_update_display_video360_advertiser_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_display_video360_advertiser_link._get_unset_required_fields( - jsonified_request - ) + ).delete_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_display_video360_advertiser_link._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",)) + ).delete_conversion_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -65799,7 +65856,7 @@ def test_update_display_video360_advertiser_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DisplayVideo360AdvertiserLink() + 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 @@ -65811,42 +65868,36 @@ def test_update_display_video360_advertiser_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLink.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"} - response = client.update_display_video360_advertiser_link(request) + response = client.delete_conversion_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_display_video360_advertiser_link_rest_unset_required_fields(): +def test_delete_conversion_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.update_display_video360_advertiser_link._get_unset_required_fields({}) - ) - assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) + unset_fields = transport.delete_conversion_event._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_display_video360_advertiser_link_rest_flattened(): +def test_delete_conversion_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -65855,50 +65906,39 @@ def test_update_display_video360_advertiser_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.DisplayVideo360AdvertiserLink() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "display_video_360_advertiser_link": { - "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" - } - } + sample_request = {"name": "properties/sample1/conversionEvents/sample2"} # get truthy value for each flattened field mock_args = dict( - display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_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.DisplayVideo360AdvertiserLink.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.update_display_video360_advertiser_link(**mock_args) + client.delete_conversion_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{display_video_360_advertiser_link.name=properties/*/displayVideo360AdvertiserLinks/*}" + "%s/v1alpha/{name=properties/*/conversionEvents/*}" % client.transport._host, args[1], ) -def test_update_display_video360_advertiser_link_rest_flattened_error( - transport: str = "rest", -): +def test_delete_conversion_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -65907,16 +65947,13 @@ def test_update_display_video360_advertiser_link_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_display_video360_advertiser_link( - analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest(), - display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.delete_conversion_event( + analytics_admin.DeleteConversionEventRequest(), + name="name_value", ) -def test_get_display_video360_advertiser_link_proposal_rest_use_cached_wrapped_rpc(): +def test_list_conversion_events_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -65931,7 +65968,7 @@ def test_get_display_video360_advertiser_link_proposal_rest_use_cached_wrapped_r # Ensure method has been cached assert ( - client._transport.get_display_video360_advertiser_link_proposal + client._transport.list_conversion_events in client._transport._wrapped_methods ) @@ -65941,29 +65978,29 @@ def test_get_display_video360_advertiser_link_proposal_rest_use_cached_wrapped_r "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_display_video360_advertiser_link_proposal + client._transport.list_conversion_events ] = mock_rpc request = {} - client.get_display_video360_advertiser_link_proposal(request) + client.list_conversion_events(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_display_video360_advertiser_link_proposal(request) + client.list_conversion_events(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_get_display_video360_advertiser_link_proposal_rest_required_fields( - request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, +def test_list_conversion_events_rest_required_fields( + request_type=analytics_admin.ListConversionEventsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -65974,25 +66011,28 @@ def test_get_display_video360_advertiser_link_proposal_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).list_conversion_events._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request + ).list_conversion_events._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -66001,7 +66041,7 @@ def test_get_display_video360_advertiser_link_proposal_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DisplayVideo360AdvertiserLinkProposal() + return_value = analytics_admin.ListConversionEventsResponse() # 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 @@ -66022,34 +66062,38 @@ def test_get_display_video360_advertiser_link_proposal_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb( - return_value - ) + return_value = analytics_admin.ListConversionEventsResponse.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_display_video360_advertiser_link_proposal(request) + response = client.list_conversion_events(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_display_video360_advertiser_link_proposal_rest_unset_required_fields(): +def test_list_conversion_events_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_display_video360_advertiser_link_proposal._get_unset_required_fields( - {} + unset_fields = transport.list_conversion_events._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) ) - assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_display_video360_advertiser_link_proposal_rest_flattened(): +def test_list_conversion_events_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -66058,16 +66102,14 @@ def test_get_display_video360_advertiser_link_proposal_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.DisplayVideo360AdvertiserLinkProposal() + return_value = analytics_admin.ListConversionEventsResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -66075,28 +66117,26 @@ def test_get_display_video360_advertiser_link_proposal_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb(return_value) + return_value = analytics_admin.ListConversionEventsResponse.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_display_video360_advertiser_link_proposal(**mock_args) + client.list_conversion_events(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinkProposals/*}" + "%s/v1alpha/{parent=properties/*}/conversionEvents" % client.transport._host, args[1], ) -def test_get_display_video360_advertiser_link_proposal_rest_flattened_error( - transport: str = "rest", -): +def test_list_conversion_events_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -66105,13 +66145,76 @@ def test_get_display_video360_advertiser_link_proposal_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_display_video360_advertiser_link_proposal( - analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest(), - name="name_value", + client.list_conversion_events( + analytics_admin.ListConversionEventsRequest(), + parent="parent_value", ) -def test_list_display_video360_advertiser_link_proposals_rest_use_cached_wrapped_rpc(): +def test_list_conversion_events_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListConversionEventsResponse( + conversion_events=[ + resources.ConversionEvent(), + resources.ConversionEvent(), + resources.ConversionEvent(), + ], + next_page_token="abc", + ), + analytics_admin.ListConversionEventsResponse( + conversion_events=[], + next_page_token="def", + ), + analytics_admin.ListConversionEventsResponse( + conversion_events=[ + resources.ConversionEvent(), + ], + next_page_token="ghi", + ), + analytics_admin.ListConversionEventsResponse( + conversion_events=[ + resources.ConversionEvent(), + resources.ConversionEvent(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListConversionEventsResponse.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": "properties/sample1"} + + pager = client.list_conversion_events(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.ConversionEvent) for i in results) + + pages = list(client.list_conversion_events(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_key_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -66125,10 +66228,7 @@ def test_list_display_video360_advertiser_link_proposals_rest_use_cached_wrapped wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_display_video360_advertiser_link_proposals - in client._transport._wrapped_methods - ) + assert client._transport.create_key_event in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -66136,24 +66236,24 @@ def test_list_display_video360_advertiser_link_proposals_rest_use_cached_wrapped "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_display_video360_advertiser_link_proposals + client._transport.create_key_event ] = mock_rpc request = {} - client.list_display_video360_advertiser_link_proposals(request) + client.create_key_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_display_video360_advertiser_link_proposals(request) + client.create_key_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_list_display_video360_advertiser_link_proposals_rest_required_fields( - request_type=analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, +def test_create_key_event_rest_required_fields( + request_type=analytics_admin.CreateKeyEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -66169,9 +66269,7 @@ def test_list_display_video360_advertiser_link_proposals_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_display_video360_advertiser_link_proposals._get_unset_required_fields( - jsonified_request - ) + ).create_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -66180,16 +66278,7 @@ def test_list_display_video360_advertiser_link_proposals_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_display_video360_advertiser_link_proposals._get_unset_required_fields( - jsonified_request - ) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).create_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -66203,7 +66292,7 @@ def test_list_display_video360_advertiser_link_proposals_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() + return_value = resources.KeyEvent() # 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 @@ -66215,53 +66304,48 @@ def test_list_display_video360_advertiser_link_proposals_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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.pb( - return_value - ) - ) + return_value = resources.KeyEvent.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_display_video360_advertiser_link_proposals(request) + response = client.create_key_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_display_video360_advertiser_link_proposals_rest_unset_required_fields(): +def test_create_key_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_display_video360_advertiser_link_proposals._get_unset_required_fields( - {} - ) + unset_fields = transport.create_key_event._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "pageSize", - "pageToken", + "keyEvent", + "parent", ) ) - & set(("parent",)) ) -def test_list_display_video360_advertiser_link_proposals_rest_flattened(): +def test_create_key_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -66270,9 +66354,7 @@ def test_list_display_video360_advertiser_link_proposals_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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() - ) + return_value = resources.KeyEvent() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -66280,6 +66362,7 @@ def test_list_display_video360_advertiser_link_proposals_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", + key_event=resources.KeyEvent(name="name_value"), ) mock_args.update(sample_request) @@ -66287,32 +66370,25 @@ def test_list_display_video360_advertiser_link_proposals_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.pb( - return_value - ) - ) + return_value = resources.KeyEvent.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_display_video360_advertiser_link_proposals(**mock_args) + client.create_key_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinkProposals" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/keyEvents" % client.transport._host, args[1], ) -def test_list_display_video360_advertiser_link_proposals_rest_flattened_error( - transport: str = "rest", -): +def test_create_key_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -66321,90 +66397,14 @@ def test_list_display_video360_advertiser_link_proposals_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_display_video360_advertiser_link_proposals( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest(), + client.create_key_event( + analytics_admin.CreateKeyEventRequest(), parent="parent_value", + key_event=resources.KeyEvent(name="name_value"), ) -def test_list_display_video360_advertiser_link_proposals_rest_pager( - transport: str = "rest", -): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( - display_video_360_advertiser_link_proposals=[ - resources.DisplayVideo360AdvertiserLinkProposal(), - resources.DisplayVideo360AdvertiserLinkProposal(), - resources.DisplayVideo360AdvertiserLinkProposal(), - ], - next_page_token="abc", - ), - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( - display_video_360_advertiser_link_proposals=[], - next_page_token="def", - ), - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( - display_video_360_advertiser_link_proposals=[ - resources.DisplayVideo360AdvertiserLinkProposal(), - ], - next_page_token="ghi", - ), - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( - display_video_360_advertiser_link_proposals=[ - resources.DisplayVideo360AdvertiserLinkProposal(), - resources.DisplayVideo360AdvertiserLinkProposal(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.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": "properties/sample1"} - - pager = client.list_display_video360_advertiser_link_proposals( - request=sample_request - ) - - results = list(pager) - assert len(results) == 6 - assert all( - isinstance(i, resources.DisplayVideo360AdvertiserLinkProposal) - for i in results - ) - - pages = list( - client.list_display_video360_advertiser_link_proposals( - request=sample_request - ).pages - ) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_create_display_video360_advertiser_link_proposal_rest_use_cached_wrapped_rpc(): +def test_update_key_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -66418,10 +66418,7 @@ def test_create_display_video360_advertiser_link_proposal_rest_use_cached_wrappe wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.create_display_video360_advertiser_link_proposal - in client._transport._wrapped_methods - ) + assert client._transport.update_key_event in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -66429,29 +66426,28 @@ def test_create_display_video360_advertiser_link_proposal_rest_use_cached_wrappe "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_display_video360_advertiser_link_proposal + client._transport.update_key_event ] = mock_rpc request = {} - client.create_display_video360_advertiser_link_proposal(request) + client.update_key_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_display_video360_advertiser_link_proposal(request) + client.update_key_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_display_video360_advertiser_link_proposal_rest_required_fields( - request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, +def test_update_key_event_rest_required_fields( + request_type=analytics_admin.UpdateKeyEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -66462,25 +66458,19 @@ def test_create_display_video360_advertiser_link_proposal_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).update_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).update_key_event._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -66489,7 +66479,7 @@ def test_create_display_video360_advertiser_link_proposal_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DisplayVideo360AdvertiserLinkProposal() + return_value = resources.KeyEvent() # 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 @@ -66501,7 +66491,7 @@ def test_create_display_video360_advertiser_link_proposal_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -66511,42 +66501,38 @@ def test_create_display_video360_advertiser_link_proposal_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb( - return_value - ) + return_value = resources.KeyEvent.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.create_display_video360_advertiser_link_proposal(request) + response = client.update_key_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_display_video360_advertiser_link_proposal_rest_unset_required_fields(): +def test_update_key_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_display_video360_advertiser_link_proposal._get_unset_required_fields( - {} - ) + unset_fields = transport.update_key_event._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) + set(("updateMask",)) & set( ( - "parent", - "displayVideo360AdvertiserLinkProposal", + "keyEvent", + "updateMask", ) ) ) -def test_create_display_video360_advertiser_link_proposal_rest_flattened(): +def test_update_key_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -66555,17 +66541,15 @@ def test_create_display_video360_advertiser_link_proposal_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.DisplayVideo360AdvertiserLinkProposal() + return_value = resources.KeyEvent() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"key_event": {"name": "properties/sample1/keyEvents/sample2"}} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - display_video_360_advertiser_link_proposal=resources.DisplayVideo360AdvertiserLinkProposal( - name="name_value" - ), + key_event=resources.KeyEvent(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -66573,28 +66557,26 @@ def test_create_display_video360_advertiser_link_proposal_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb(return_value) + return_value = resources.KeyEvent.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_display_video360_advertiser_link_proposal(**mock_args) + client.update_key_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinkProposals" + "%s/v1alpha/{key_event.name=properties/*/keyEvents/*}" % client.transport._host, args[1], ) -def test_create_display_video360_advertiser_link_proposal_rest_flattened_error( - transport: str = "rest", -): +def test_update_key_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -66603,16 +66585,14 @@ def test_create_display_video360_advertiser_link_proposal_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_display_video360_advertiser_link_proposal( - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest(), - parent="parent_value", - display_video_360_advertiser_link_proposal=resources.DisplayVideo360AdvertiserLinkProposal( - name="name_value" - ), + client.update_key_event( + analytics_admin.UpdateKeyEventRequest(), + key_event=resources.KeyEvent(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_display_video360_advertiser_link_proposal_rest_use_cached_wrapped_rpc(): +def test_get_key_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -66626,35 +66606,30 @@ def test_delete_display_video360_advertiser_link_proposal_rest_use_cached_wrappe wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_display_video360_advertiser_link_proposal - in client._transport._wrapped_methods - ) + assert client._transport.get_key_event in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[ - client._transport.delete_display_video360_advertiser_link_proposal - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_key_event] = mock_rpc request = {} - client.delete_display_video360_advertiser_link_proposal(request) + client.get_key_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_display_video360_advertiser_link_proposal(request) + client.get_key_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_delete_display_video360_advertiser_link_proposal_rest_required_fields( - request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, +def test_get_key_event_rest_required_fields( + request_type=analytics_admin.GetKeyEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -66670,9 +66645,7 @@ def test_delete_display_video360_advertiser_link_proposal_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).get_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -66681,9 +66654,7 @@ def test_delete_display_video360_advertiser_link_proposal_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).get_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -66697,7 +66668,7 @@ def test_delete_display_video360_advertiser_link_proposal_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.KeyEvent() # 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 @@ -66709,38 +66680,39 @@ def test_delete_display_video360_advertiser_link_proposal_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.KeyEvent.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_display_video360_advertiser_link_proposal(request) + response = client.get_key_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_display_video360_advertiser_link_proposal_rest_unset_required_fields(): +def test_get_key_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_display_video360_advertiser_link_proposal._get_unset_required_fields( - {} - ) + unset_fields = transport.get_key_event._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_display_video360_advertiser_link_proposal_rest_flattened(): +def test_get_key_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -66749,12 +66721,10 @@ def test_delete_display_video360_advertiser_link_proposal_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 = resources.KeyEvent() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" - } + sample_request = {"name": "properties/sample1/keyEvents/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -66765,27 +66735,26 @@ def test_delete_display_video360_advertiser_link_proposal_rest_flattened(): # 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 = resources.KeyEvent.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_display_video360_advertiser_link_proposal(**mock_args) + client.get_key_event(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinkProposals/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/keyEvents/*}" % client.transport._host, args[1], ) -def test_delete_display_video360_advertiser_link_proposal_rest_flattened_error( - transport: str = "rest", -): +def test_get_key_event_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -66794,13 +66763,13 @@ def test_delete_display_video360_advertiser_link_proposal_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_display_video360_advertiser_link_proposal( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest(), + client.get_key_event( + analytics_admin.GetKeyEventRequest(), name="name_value", ) -def test_approve_display_video360_advertiser_link_proposal_rest_use_cached_wrapped_rpc(): +def test_delete_key_event_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -66814,10 +66783,7 @@ def test_approve_display_video360_advertiser_link_proposal_rest_use_cached_wrapp wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.approve_display_video360_advertiser_link_proposal - in client._transport._wrapped_methods - ) + assert client._transport.delete_key_event in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -66825,24 +66791,24 @@ def test_approve_display_video360_advertiser_link_proposal_rest_use_cached_wrapp "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.approve_display_video360_advertiser_link_proposal + client._transport.delete_key_event ] = mock_rpc request = {} - client.approve_display_video360_advertiser_link_proposal(request) + client.delete_key_event(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.approve_display_video360_advertiser_link_proposal(request) + client.delete_key_event(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_approve_display_video360_advertiser_link_proposal_rest_required_fields( - request_type=analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, +def test_delete_key_event_rest_required_fields( + request_type=analytics_admin.DeleteKeyEventRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -66858,9 +66824,7 @@ def test_approve_display_video360_advertiser_link_proposal_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).approve_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).delete_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -66869,9 +66833,7 @@ def test_approve_display_video360_advertiser_link_proposal_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).approve_display_video360_advertiser_link_proposal._get_unset_required_fields( - jsonified_request - ) + ).delete_key_event._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -66885,9 +66847,7 @@ def test_approve_display_video360_advertiser_link_proposal_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() - ) + 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 @@ -66899,180 +66859,91 @@ def test_approve_display_video360_advertiser_link_proposal_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse.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"} - response = client.approve_display_video360_advertiser_link_proposal(request) + response = client.delete_key_event(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_approve_display_video360_advertiser_link_proposal_rest_unset_required_fields(): +def test_delete_key_event_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.approve_display_video360_advertiser_link_proposal._get_unset_required_fields( - {} - ) + unset_fields = transport.delete_key_event._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_cancel_display_video360_advertiser_link_proposal_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 = AnalyticsAdminServiceClient( - 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.cancel_display_video360_advertiser_link_proposal - 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.cancel_display_video360_advertiser_link_proposal - ] = mock_rpc - - request = {} - client.cancel_display_video360_advertiser_link_proposal(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.cancel_display_video360_advertiser_link_proposal(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_cancel_display_video360_advertiser_link_proposal_rest_required_fields( - request_type=analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - - 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() - ).cancel_display_video360_advertiser_link_proposal._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() - ).cancel_display_video360_advertiser_link_proposal._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" - +def test_delete_key_event_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = resources.DisplayVideo360AdvertiserLinkProposal() # 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 + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None - response_value = Response() - response_value.status_code = 200 + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/keyEvents/sample2"} - # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb( - return_value - ) - json_return_value = json_format.MessageToJson(return_value) + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_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"} + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.cancel_display_video360_advertiser_link_proposal(request) + client.delete_key_event(**mock_args) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # 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=properties/*/keyEvents/*}" % client.transport._host, + args[1], + ) -def test_cancel_display_video360_advertiser_link_proposal_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_delete_key_event_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - unset_fields = transport.cancel_display_video360_advertiser_link_proposal._get_unset_required_fields( - {} - ) - assert set(unset_fields) == (set(()) & set(("name",))) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_key_event( + analytics_admin.DeleteKeyEventRequest(), + name="name_value", + ) -def test_create_custom_dimension_rest_use_cached_wrapped_rpc(): +def test_list_key_events_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -67086,35 +66957,30 @@ def test_create_custom_dimension_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.create_custom_dimension - in client._transport._wrapped_methods - ) + assert client._transport.list_key_events in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() mock_rpc.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client._transport._wrapped_methods[ - client._transport.create_custom_dimension - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_key_events] = mock_rpc request = {} - client.create_custom_dimension(request) + client.list_key_events(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_custom_dimension(request) + client.list_key_events(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_create_custom_dimension_rest_required_fields( - request_type=analytics_admin.CreateCustomDimensionRequest, +def test_list_key_events_rest_required_fields( + request_type=analytics_admin.ListKeyEventsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -67130,7 +66996,7 @@ def test_create_custom_dimension_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_custom_dimension._get_unset_required_fields(jsonified_request) + ).list_key_events._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -67139,7 +67005,14 @@ def test_create_custom_dimension_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_custom_dimension._get_unset_required_fields(jsonified_request) + ).list_key_events._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -67153,7 +67026,7 @@ def test_create_custom_dimension_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CustomDimension() + return_value = analytics_admin.ListKeyEventsResponse() # 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 @@ -67165,48 +67038,47 @@ def test_create_custom_dimension_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomDimension.pb(return_value) + return_value = analytics_admin.ListKeyEventsResponse.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.create_custom_dimension(request) + response = client.list_key_events(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_custom_dimension_rest_unset_required_fields(): +def test_list_key_events_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_custom_dimension._get_unset_required_fields({}) + unset_fields = transport.list_key_events._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) - & set( + set( ( - "parent", - "customDimension", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_create_custom_dimension_rest_flattened(): +def test_list_key_events_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -67215,7 +67087,7 @@ def test_create_custom_dimension_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.CustomDimension() + return_value = analytics_admin.ListKeyEventsResponse() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -67223,7 +67095,6 @@ def test_create_custom_dimension_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", - custom_dimension=resources.CustomDimension(name="name_value"), ) mock_args.update(sample_request) @@ -67231,26 +67102,25 @@ def test_create_custom_dimension_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomDimension.pb(return_value) + return_value = analytics_admin.ListKeyEventsResponse.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_custom_dimension(**mock_args) + client.list_key_events(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1alpha/{parent=properties/*}/customDimensions" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/keyEvents" % client.transport._host, args[1], ) -def test_create_custom_dimension_rest_flattened_error(transport: str = "rest"): +def test_list_key_events_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -67259,14 +67129,76 @@ def test_create_custom_dimension_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_custom_dimension( - analytics_admin.CreateCustomDimensionRequest(), + client.list_key_events( + analytics_admin.ListKeyEventsRequest(), parent="parent_value", - custom_dimension=resources.CustomDimension(name="name_value"), ) -def test_update_custom_dimension_rest_use_cached_wrapped_rpc(): +def test_list_key_events_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListKeyEventsResponse( + key_events=[ + resources.KeyEvent(), + resources.KeyEvent(), + resources.KeyEvent(), + ], + next_page_token="abc", + ), + analytics_admin.ListKeyEventsResponse( + key_events=[], + next_page_token="def", + ), + analytics_admin.ListKeyEventsResponse( + key_events=[ + resources.KeyEvent(), + ], + next_page_token="ghi", + ), + analytics_admin.ListKeyEventsResponse( + key_events=[ + resources.KeyEvent(), + resources.KeyEvent(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListKeyEventsResponse.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": "properties/sample1"} + + pager = client.list_key_events(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.KeyEvent) for i in results) + + pages = list(client.list_key_events(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_display_video360_advertiser_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: @@ -67281,7 +67213,7 @@ def test_update_custom_dimension_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_custom_dimension + client._transport.get_display_video360_advertiser_link in client._transport._wrapped_methods ) @@ -67291,28 +67223,29 @@ def test_update_custom_dimension_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_custom_dimension + client._transport.get_display_video360_advertiser_link ] = mock_rpc request = {} - client.update_custom_dimension(request) + client.get_display_video360_advertiser_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_custom_dimension(request) + client.get_display_video360_advertiser_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_update_custom_dimension_rest_required_fields( - request_type=analytics_admin.UpdateCustomDimensionRequest, +def test_get_display_video360_advertiser_link_rest_required_fields( + request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -67323,19 +67256,21 @@ def test_update_custom_dimension_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_custom_dimension._get_unset_required_fields(jsonified_request) + ).get_display_video360_advertiser_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() - ).update_custom_dimension._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).get_display_video360_advertiser_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -67344,7 +67279,7 @@ def test_update_custom_dimension_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CustomDimension() + return_value = resources.DisplayVideo360AdvertiserLink() # 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 @@ -67356,40 +67291,41 @@ def test_update_custom_dimension_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 = resources.CustomDimension.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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_custom_dimension(request) + response = client.get_display_video360_advertiser_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_custom_dimension_rest_unset_required_fields(): +def test_get_display_video360_advertiser_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_custom_dimension._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) + unset_fields = ( + transport.get_display_video360_advertiser_link._get_unset_required_fields({}) + ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_custom_dimension_rest_flattened(): +def test_get_display_video360_advertiser_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -67398,17 +67334,16 @@ def test_update_custom_dimension_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.CustomDimension() + return_value = resources.DisplayVideo360AdvertiserLink() # get arguments that satisfy an http rule for this method sample_request = { - "custom_dimension": {"name": "properties/sample1/customDimensions/sample2"} + "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" } # get truthy value for each flattened field mock_args = dict( - custom_dimension=resources.CustomDimension(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) @@ -67416,26 +67351,28 @@ def test_update_custom_dimension_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomDimension.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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.update_custom_dimension(**mock_args) + client.get_display_video360_advertiser_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/{custom_dimension.name=properties/*/customDimensions/*}" + "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinks/*}" % client.transport._host, args[1], ) -def test_update_custom_dimension_rest_flattened_error(transport: str = "rest"): +def test_get_display_video360_advertiser_link_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -67444,14 +67381,13 @@ def test_update_custom_dimension_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_custom_dimension( - analytics_admin.UpdateCustomDimensionRequest(), - custom_dimension=resources.CustomDimension(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_display_video360_advertiser_link( + analytics_admin.GetDisplayVideo360AdvertiserLinkRequest(), + name="name_value", ) -def test_list_custom_dimensions_rest_use_cached_wrapped_rpc(): +def test_list_display_video360_advertiser_links_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: @@ -67466,7 +67402,7 @@ def test_list_custom_dimensions_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_custom_dimensions + client._transport.list_display_video360_advertiser_links in client._transport._wrapped_methods ) @@ -67476,24 +67412,24 @@ def test_list_custom_dimensions_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_custom_dimensions + client._transport.list_display_video360_advertiser_links ] = mock_rpc request = {} - client.list_custom_dimensions(request) + client.list_display_video360_advertiser_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_custom_dimensions(request) + client.list_display_video360_advertiser_links(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_custom_dimensions_rest_required_fields( - request_type=analytics_admin.ListCustomDimensionsRequest, +def test_list_display_video360_advertiser_links_rest_required_fields( + request_type=analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -67509,7 +67445,9 @@ def test_list_custom_dimensions_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_custom_dimensions._get_unset_required_fields(jsonified_request) + ).list_display_video360_advertiser_links._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -67518,7 +67456,9 @@ def test_list_custom_dimensions_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_custom_dimensions._get_unset_required_fields(jsonified_request) + ).list_display_video360_advertiser_links._get_unset_required_fields( + jsonified_request + ) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( @@ -67539,7 +67479,7 @@ def test_list_custom_dimensions_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListCustomDimensionsResponse() + return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() # 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 @@ -67560,26 +67500,32 @@ def test_list_custom_dimensions_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCustomDimensionsResponse.pb(return_value) + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.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_custom_dimensions(request) + response = client.list_display_video360_advertiser_links(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_custom_dimensions_rest_unset_required_fields(): +def test_list_display_video360_advertiser_links_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_custom_dimensions._get_unset_required_fields({}) + unset_fields = ( + transport.list_display_video360_advertiser_links._get_unset_required_fields({}) + ) assert set(unset_fields) == ( set( ( @@ -67591,7 +67537,7 @@ def test_list_custom_dimensions_rest_unset_required_fields(): ) -def test_list_custom_dimensions_rest_flattened(): +def test_list_display_video360_advertiser_links_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -67600,7 +67546,7 @@ def test_list_custom_dimensions_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 = analytics_admin.ListCustomDimensionsResponse() + return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -67615,26 +67561,30 @@ def test_list_custom_dimensions_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCustomDimensionsResponse.pb(return_value) + return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.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_custom_dimensions(**mock_args) + client.list_display_video360_advertiser_links(**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=properties/*}/customDimensions" + "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinks" % client.transport._host, args[1], ) -def test_list_custom_dimensions_rest_flattened_error(transport: str = "rest"): +def test_list_display_video360_advertiser_links_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -67643,13 +67593,13 @@ def test_list_custom_dimensions_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_custom_dimensions( - analytics_admin.ListCustomDimensionsRequest(), + client.list_display_video360_advertiser_links( + analytics_admin.ListDisplayVideo360AdvertiserLinksRequest(), parent="parent_value", ) -def test_list_custom_dimensions_rest_pager(transport: str = "rest"): +def test_list_display_video360_advertiser_links_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -67661,28 +67611,28 @@ def test_list_custom_dimensions_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListCustomDimensionsResponse( - custom_dimensions=[ - resources.CustomDimension(), - resources.CustomDimension(), - resources.CustomDimension(), + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + display_video_360_advertiser_links=[ + resources.DisplayVideo360AdvertiserLink(), + resources.DisplayVideo360AdvertiserLink(), + resources.DisplayVideo360AdvertiserLink(), ], next_page_token="abc", ), - analytics_admin.ListCustomDimensionsResponse( - custom_dimensions=[], + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + display_video_360_advertiser_links=[], next_page_token="def", ), - analytics_admin.ListCustomDimensionsResponse( - custom_dimensions=[ - resources.CustomDimension(), + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + display_video_360_advertiser_links=[ + resources.DisplayVideo360AdvertiserLink(), ], next_page_token="ghi", ), - analytics_admin.ListCustomDimensionsResponse( - custom_dimensions=[ - resources.CustomDimension(), - resources.CustomDimension(), + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + display_video_360_advertiser_links=[ + resources.DisplayVideo360AdvertiserLink(), + resources.DisplayVideo360AdvertiserLink(), ], ), ) @@ -67691,7 +67641,8 @@ def test_list_custom_dimensions_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListCustomDimensionsResponse.to_json(x) for x in response + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.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): @@ -67701,18 +67652,22 @@ def test_list_custom_dimensions_rest_pager(transport: str = "rest"): sample_request = {"parent": "properties/sample1"} - pager = client.list_custom_dimensions(request=sample_request) + pager = client.list_display_video360_advertiser_links(request=sample_request) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.CustomDimension) for i in results) + assert all( + isinstance(i, resources.DisplayVideo360AdvertiserLink) for i in results + ) - pages = list(client.list_custom_dimensions(request=sample_request).pages) + pages = list( + client.list_display_video360_advertiser_links(request=sample_request).pages + ) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_archive_custom_dimension_rest_use_cached_wrapped_rpc(): +def test_create_display_video360_advertiser_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: @@ -67727,7 +67682,7 @@ def test_archive_custom_dimension_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.archive_custom_dimension + client._transport.create_display_video360_advertiser_link in client._transport._wrapped_methods ) @@ -67737,29 +67692,29 @@ def test_archive_custom_dimension_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.archive_custom_dimension + client._transport.create_display_video360_advertiser_link ] = mock_rpc request = {} - client.archive_custom_dimension(request) + client.create_display_video360_advertiser_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.archive_custom_dimension(request) + client.create_display_video360_advertiser_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_archive_custom_dimension_rest_required_fields( - request_type=analytics_admin.ArchiveCustomDimensionRequest, +def test_create_display_video360_advertiser_link_rest_required_fields( + request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -67770,21 +67725,25 @@ def test_archive_custom_dimension_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).archive_custom_dimension._get_unset_required_fields(jsonified_request) + ).create_display_video360_advertiser_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" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).archive_custom_dimension._get_unset_required_fields(jsonified_request) + ).create_display_video360_advertiser_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" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -67793,7 +67752,7 @@ def test_archive_custom_dimension_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.DisplayVideo360AdvertiserLink() # 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 @@ -67813,29 +67772,42 @@ def test_archive_custom_dimension_rest_required_fields( response_value = Response() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.DisplayVideo360AdvertiserLink.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.archive_custom_dimension(request) + response = client.create_display_video360_advertiser_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_archive_custom_dimension_rest_unset_required_fields(): +def test_create_display_video360_advertiser_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.archive_custom_dimension._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = ( + transport.create_display_video360_advertiser_link._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "displayVideo360AdvertiserLink", + ) + ) + ) -def test_archive_custom_dimension_rest_flattened(): +def test_create_display_video360_advertiser_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -67844,39 +67816,46 @@ def test_archive_custom_dimension_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 = resources.DisplayVideo360AdvertiserLink() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/customDimensions/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( + 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 = "" + # Convert return value to protobuf type + return_value = resources.DisplayVideo360AdvertiserLink.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.archive_custom_dimension(**mock_args) + client.create_display_video360_advertiser_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/{name=properties/*/customDimensions/*}:archive" + "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinks" % client.transport._host, args[1], ) -def test_archive_custom_dimension_rest_flattened_error(transport: str = "rest"): +def test_create_display_video360_advertiser_link_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -67885,13 +67864,16 @@ def test_archive_custom_dimension_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.archive_custom_dimension( - analytics_admin.ArchiveCustomDimensionRequest(), - name="name_value", + client.create_display_video360_advertiser_link( + analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest(), + parent="parent_value", + display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( + name="name_value" + ), ) -def test_get_custom_dimension_rest_use_cached_wrapped_rpc(): +def test_delete_display_video360_advertiser_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: @@ -67906,7 +67888,8 @@ def test_get_custom_dimension_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_custom_dimension in client._transport._wrapped_methods + client._transport.delete_display_video360_advertiser_link + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -67915,24 +67898,24 @@ def test_get_custom_dimension_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_custom_dimension + client._transport.delete_display_video360_advertiser_link ] = mock_rpc request = {} - client.get_custom_dimension(request) + client.delete_display_video360_advertiser_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_custom_dimension(request) + client.delete_display_video360_advertiser_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_get_custom_dimension_rest_required_fields( - request_type=analytics_admin.GetCustomDimensionRequest, +def test_delete_display_video360_advertiser_link_rest_required_fields( + request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -67948,7 +67931,9 @@ def test_get_custom_dimension_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_custom_dimension._get_unset_required_fields(jsonified_request) + ).delete_display_video360_advertiser_link._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -67957,7 +67942,9 @@ def test_get_custom_dimension_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_custom_dimension._get_unset_required_fields(jsonified_request) + ).delete_display_video360_advertiser_link._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -67971,7 +67958,7 @@ def test_get_custom_dimension_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CustomDimension() + 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 @@ -67983,39 +67970,38 @@ def test_get_custom_dimension_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "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.CustomDimension.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"} - response = client.get_custom_dimension(request) + response = client.delete_display_video360_advertiser_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_custom_dimension_rest_unset_required_fields(): +def test_delete_display_video360_advertiser_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_custom_dimension._get_unset_required_fields({}) + unset_fields = ( + transport.delete_display_video360_advertiser_link._get_unset_required_fields({}) + ) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_custom_dimension_rest_flattened(): +def test_delete_display_video360_advertiser_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -68024,10 +68010,12 @@ def test_get_custom_dimension_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.CustomDimension() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/customDimensions/sample2"} + sample_request = { + "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" + } # get truthy value for each flattened field mock_args = dict( @@ -68038,27 +68026,27 @@ def test_get_custom_dimension_rest_flattened(): # 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.CustomDimension.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.get_custom_dimension(**mock_args) + client.delete_display_video360_advertiser_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/{name=properties/*/customDimensions/*}" + "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinks/*}" % client.transport._host, args[1], ) -def test_get_custom_dimension_rest_flattened_error(transport: str = "rest"): +def test_delete_display_video360_advertiser_link_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -68067,13 +68055,13 @@ def test_get_custom_dimension_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_custom_dimension( - analytics_admin.GetCustomDimensionRequest(), + client.delete_display_video360_advertiser_link( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest(), name="name_value", ) -def test_create_custom_metric_rest_use_cached_wrapped_rpc(): +def test_update_display_video360_advertiser_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: @@ -68088,7 +68076,8 @@ def test_create_custom_metric_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_custom_metric in client._transport._wrapped_methods + client._transport.update_display_video360_advertiser_link + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -68097,29 +68086,28 @@ def test_create_custom_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_custom_metric + client._transport.update_display_video360_advertiser_link ] = mock_rpc request = {} - client.create_custom_metric(request) + client.update_display_video360_advertiser_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_custom_metric(request) + client.update_display_video360_advertiser_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_create_custom_metric_rest_required_fields( - request_type=analytics_admin.CreateCustomMetricRequest, +def test_update_display_video360_advertiser_link_rest_required_fields( + request_type=analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -68130,21 +68118,23 @@ def test_create_custom_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_custom_metric._get_unset_required_fields(jsonified_request) + ).update_display_video360_advertiser_link._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_custom_metric._get_unset_required_fields(jsonified_request) + ).update_display_video360_advertiser_link._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -68153,7 +68143,7 @@ def test_create_custom_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CustomMetric() + return_value = resources.DisplayVideo360AdvertiserLink() # 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 @@ -68165,7 +68155,7 @@ def test_create_custom_metric_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -68175,38 +68165,32 @@ def test_create_custom_metric_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomMetric.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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.create_custom_metric(request) + response = client.update_display_video360_advertiser_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_custom_metric_rest_unset_required_fields(): +def test_update_display_video360_advertiser_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_custom_metric._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "customMetric", - ) - ) + unset_fields = ( + transport.update_display_video360_advertiser_link._get_unset_required_fields({}) ) + assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) -def test_create_custom_metric_rest_flattened(): +def test_update_display_video360_advertiser_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -68215,15 +68199,21 @@ def test_create_custom_metric_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.CustomMetric() + return_value = resources.DisplayVideo360AdvertiserLink() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "display_video_360_advertiser_link": { + "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" + } + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - custom_metric=resources.CustomMetric(name="name_value"), + display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -68231,25 +68221,28 @@ def test_create_custom_metric_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomMetric.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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_custom_metric(**mock_args) + client.update_display_video360_advertiser_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=properties/*}/customMetrics" % client.transport._host, + "%s/v1alpha/{display_video_360_advertiser_link.name=properties/*/displayVideo360AdvertiserLinks/*}" + % client.transport._host, args[1], ) -def test_create_custom_metric_rest_flattened_error(transport: str = "rest"): +def test_update_display_video360_advertiser_link_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -68258,14 +68251,16 @@ def test_create_custom_metric_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_custom_metric( - analytics_admin.CreateCustomMetricRequest(), - parent="parent_value", - custom_metric=resources.CustomMetric(name="name_value"), + client.update_display_video360_advertiser_link( + analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest(), + display_video_360_advertiser_link=resources.DisplayVideo360AdvertiserLink( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_custom_metric_rest_use_cached_wrapped_rpc(): +def test_get_display_video360_advertiser_link_proposal_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: @@ -68280,7 +68275,8 @@ def test_update_custom_metric_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_custom_metric in client._transport._wrapped_methods + client._transport.get_display_video360_advertiser_link_proposal + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -68289,28 +68285,29 @@ def test_update_custom_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_custom_metric + client._transport.get_display_video360_advertiser_link_proposal ] = mock_rpc request = {} - client.update_custom_metric(request) + client.get_display_video360_advertiser_link_proposal(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_custom_metric(request) + client.get_display_video360_advertiser_link_proposal(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_custom_metric_rest_required_fields( - request_type=analytics_admin.UpdateCustomMetricRequest, +def test_get_display_video360_advertiser_link_proposal_rest_required_fields( + request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -68321,19 +68318,25 @@ def test_update_custom_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_custom_metric._get_unset_required_fields(jsonified_request) + ).get_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_custom_metric._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).get_display_video360_advertiser_link_proposal._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -68342,7 +68345,7 @@ def test_update_custom_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CustomMetric() + return_value = resources.DisplayVideo360AdvertiserLinkProposal() # 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 @@ -68354,40 +68357,43 @@ def test_update_custom_metric_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 = resources.CustomMetric.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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_custom_metric(request) + response = client.get_display_video360_advertiser_link_proposal(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_custom_metric_rest_unset_required_fields(): +def test_get_display_video360_advertiser_link_proposal_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_custom_metric._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) + unset_fields = transport.get_display_video360_advertiser_link_proposal._get_unset_required_fields( + {} + ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_custom_metric_rest_flattened(): +def test_get_display_video360_advertiser_link_proposal_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -68396,17 +68402,16 @@ def test_update_custom_metric_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.CustomMetric() + return_value = resources.DisplayVideo360AdvertiserLinkProposal() # get arguments that satisfy an http rule for this method sample_request = { - "custom_metric": {"name": "properties/sample1/customMetrics/sample2"} + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" } # get truthy value for each flattened field mock_args = dict( - custom_metric=resources.CustomMetric(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) @@ -68414,26 +68419,28 @@ def test_update_custom_metric_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomMetric.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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.update_custom_metric(**mock_args) + client.get_display_video360_advertiser_link_proposal(**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/{custom_metric.name=properties/*/customMetrics/*}" + "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinkProposals/*}" % client.transport._host, args[1], ) -def test_update_custom_metric_rest_flattened_error(transport: str = "rest"): +def test_get_display_video360_advertiser_link_proposal_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -68442,14 +68449,13 @@ def test_update_custom_metric_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_custom_metric( - analytics_admin.UpdateCustomMetricRequest(), - custom_metric=resources.CustomMetric(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_display_video360_advertiser_link_proposal( + analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest(), + name="name_value", ) -def test_list_custom_metrics_rest_use_cached_wrapped_rpc(): +def test_list_display_video360_advertiser_link_proposals_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: @@ -68464,7 +68470,8 @@ def test_list_custom_metrics_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_custom_metrics in client._transport._wrapped_methods + client._transport.list_display_video360_advertiser_link_proposals + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -68473,24 +68480,24 @@ def test_list_custom_metrics_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_custom_metrics + client._transport.list_display_video360_advertiser_link_proposals ] = mock_rpc request = {} - client.list_custom_metrics(request) + client.list_display_video360_advertiser_link_proposals(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_custom_metrics(request) + client.list_display_video360_advertiser_link_proposals(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_custom_metrics_rest_required_fields( - request_type=analytics_admin.ListCustomMetricsRequest, +def test_list_display_video360_advertiser_link_proposals_rest_required_fields( + request_type=analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -68506,7 +68513,9 @@ def test_list_custom_metrics_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_custom_metrics._get_unset_required_fields(jsonified_request) + ).list_display_video360_advertiser_link_proposals._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -68515,7 +68524,9 @@ def test_list_custom_metrics_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_custom_metrics._get_unset_required_fields(jsonified_request) + ).list_display_video360_advertiser_link_proposals._get_unset_required_fields( + jsonified_request + ) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( @@ -68536,7 +68547,7 @@ def test_list_custom_metrics_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListCustomMetricsResponse() + return_value = analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() # 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 @@ -68557,26 +68568,32 @@ def test_list_custom_metrics_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCustomMetricsResponse.pb(return_value) + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.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_custom_metrics(request) + response = client.list_display_video360_advertiser_link_proposals(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_custom_metrics_rest_unset_required_fields(): +def test_list_display_video360_advertiser_link_proposals_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_custom_metrics._get_unset_required_fields({}) + unset_fields = transport.list_display_video360_advertiser_link_proposals._get_unset_required_fields( + {} + ) assert set(unset_fields) == ( set( ( @@ -68588,7 +68605,7 @@ def test_list_custom_metrics_rest_unset_required_fields(): ) -def test_list_custom_metrics_rest_flattened(): +def test_list_display_video360_advertiser_link_proposals_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -68597,7 +68614,9 @@ def test_list_custom_metrics_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 = analytics_admin.ListCustomMetricsResponse() + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() + ) # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -68612,25 +68631,32 @@ def test_list_custom_metrics_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCustomMetricsResponse.pb(return_value) + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.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_custom_metrics(**mock_args) + client.list_display_video360_advertiser_link_proposals(**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=properties/*}/customMetrics" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinkProposals" + % client.transport._host, args[1], ) -def test_list_custom_metrics_rest_flattened_error(transport: str = "rest"): +def test_list_display_video360_advertiser_link_proposals_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -68639,13 +68665,15 @@ def test_list_custom_metrics_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_custom_metrics( - analytics_admin.ListCustomMetricsRequest(), + client.list_display_video360_advertiser_link_proposals( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest(), parent="parent_value", ) -def test_list_custom_metrics_rest_pager(transport: str = "rest"): +def test_list_display_video360_advertiser_link_proposals_rest_pager( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -68657,28 +68685,28 @@ def test_list_custom_metrics_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListCustomMetricsResponse( - custom_metrics=[ - resources.CustomMetric(), - resources.CustomMetric(), - resources.CustomMetric(), + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( + display_video_360_advertiser_link_proposals=[ + resources.DisplayVideo360AdvertiserLinkProposal(), + resources.DisplayVideo360AdvertiserLinkProposal(), + resources.DisplayVideo360AdvertiserLinkProposal(), ], next_page_token="abc", ), - analytics_admin.ListCustomMetricsResponse( - custom_metrics=[], + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( + display_video_360_advertiser_link_proposals=[], next_page_token="def", ), - analytics_admin.ListCustomMetricsResponse( - custom_metrics=[ - resources.CustomMetric(), + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( + display_video_360_advertiser_link_proposals=[ + resources.DisplayVideo360AdvertiserLinkProposal(), ], next_page_token="ghi", ), - analytics_admin.ListCustomMetricsResponse( - custom_metrics=[ - resources.CustomMetric(), - resources.CustomMetric(), + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( + display_video_360_advertiser_link_proposals=[ + resources.DisplayVideo360AdvertiserLinkProposal(), + resources.DisplayVideo360AdvertiserLinkProposal(), ], ), ) @@ -68687,7 +68715,10 @@ def test_list_custom_metrics_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListCustomMetricsResponse.to_json(x) for x in response + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.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): @@ -68697,18 +68728,27 @@ def test_list_custom_metrics_rest_pager(transport: str = "rest"): sample_request = {"parent": "properties/sample1"} - pager = client.list_custom_metrics(request=sample_request) + pager = client.list_display_video360_advertiser_link_proposals( + request=sample_request + ) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.CustomMetric) for i in results) + assert all( + isinstance(i, resources.DisplayVideo360AdvertiserLinkProposal) + for i in results + ) - pages = list(client.list_custom_metrics(request=sample_request).pages) + pages = list( + client.list_display_video360_advertiser_link_proposals( + request=sample_request + ).pages + ) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_archive_custom_metric_rest_use_cached_wrapped_rpc(): +def test_create_display_video360_advertiser_link_proposal_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: @@ -68723,7 +68763,7 @@ def test_archive_custom_metric_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.archive_custom_metric + client._transport.create_display_video360_advertiser_link_proposal in client._transport._wrapped_methods ) @@ -68733,29 +68773,29 @@ def test_archive_custom_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.archive_custom_metric + client._transport.create_display_video360_advertiser_link_proposal ] = mock_rpc request = {} - client.archive_custom_metric(request) + client.create_display_video360_advertiser_link_proposal(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.archive_custom_metric(request) + client.create_display_video360_advertiser_link_proposal(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_archive_custom_metric_rest_required_fields( - request_type=analytics_admin.ArchiveCustomMetricRequest, +def test_create_display_video360_advertiser_link_proposal_rest_required_fields( + request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -68766,21 +68806,25 @@ def test_archive_custom_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).archive_custom_metric._get_unset_required_fields(jsonified_request) + ).create_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).archive_custom_metric._get_unset_required_fields(jsonified_request) + ).create_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -68789,7 +68833,7 @@ def test_archive_custom_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.DisplayVideo360AdvertiserLinkProposal() # 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 @@ -68809,29 +68853,44 @@ def test_archive_custom_metric_rest_required_fields( response_value = Response() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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.archive_custom_metric(request) + response = client.create_display_video360_advertiser_link_proposal(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_archive_custom_metric_rest_unset_required_fields(): +def test_create_display_video360_advertiser_link_proposal_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.archive_custom_metric._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_display_video360_advertiser_link_proposal._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "displayVideo360AdvertiserLinkProposal", + ) + ) + ) -def test_archive_custom_metric_rest_flattened(): +def test_create_display_video360_advertiser_link_proposal_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -68840,39 +68899,46 @@ def test_archive_custom_metric_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 = resources.DisplayVideo360AdvertiserLinkProposal() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/customMetrics/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + display_video_360_advertiser_link_proposal=resources.DisplayVideo360AdvertiserLinkProposal( + 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 = "" + # Convert return value to protobuf type + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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.archive_custom_metric(**mock_args) + client.create_display_video360_advertiser_link_proposal(**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=properties/*/customMetrics/*}:archive" + "%s/v1alpha/{parent=properties/*}/displayVideo360AdvertiserLinkProposals" % client.transport._host, args[1], ) -def test_archive_custom_metric_rest_flattened_error(transport: str = "rest"): +def test_create_display_video360_advertiser_link_proposal_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -68881,13 +68947,16 @@ def test_archive_custom_metric_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.archive_custom_metric( - analytics_admin.ArchiveCustomMetricRequest(), - name="name_value", + client.create_display_video360_advertiser_link_proposal( + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest(), + parent="parent_value", + display_video_360_advertiser_link_proposal=resources.DisplayVideo360AdvertiserLinkProposal( + name="name_value" + ), ) -def test_get_custom_metric_rest_use_cached_wrapped_rpc(): +def test_delete_display_video360_advertiser_link_proposal_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: @@ -68901,7 +68970,10 @@ def test_get_custom_metric_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_custom_metric in client._transport._wrapped_methods + assert ( + client._transport.delete_display_video360_advertiser_link_proposal + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -68909,24 +68981,24 @@ def test_get_custom_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_custom_metric + client._transport.delete_display_video360_advertiser_link_proposal ] = mock_rpc request = {} - client.get_custom_metric(request) + client.delete_display_video360_advertiser_link_proposal(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_custom_metric(request) + client.delete_display_video360_advertiser_link_proposal(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_custom_metric_rest_required_fields( - request_type=analytics_admin.GetCustomMetricRequest, +def test_delete_display_video360_advertiser_link_proposal_rest_required_fields( + request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -68942,7 +69014,9 @@ def test_get_custom_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_custom_metric._get_unset_required_fields(jsonified_request) + ).delete_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -68951,7 +69025,9 @@ def test_get_custom_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_custom_metric._get_unset_required_fields(jsonified_request) + ).delete_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -68965,7 +69041,7 @@ def test_get_custom_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CustomMetric() + 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 @@ -68977,39 +69053,38 @@ def test_get_custom_metric_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "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.CustomMetric.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"} - response = client.get_custom_metric(request) + response = client.delete_display_video360_advertiser_link_proposal(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_custom_metric_rest_unset_required_fields(): +def test_delete_display_video360_advertiser_link_proposal_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_custom_metric._get_unset_required_fields({}) + unset_fields = transport.delete_display_video360_advertiser_link_proposal._get_unset_required_fields( + {} + ) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_custom_metric_rest_flattened(): +def test_delete_display_video360_advertiser_link_proposal_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -69018,10 +69093,12 @@ def test_get_custom_metric_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.CustomMetric() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/customMetrics/sample2"} + sample_request = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } # get truthy value for each flattened field mock_args = dict( @@ -69032,26 +69109,27 @@ def test_get_custom_metric_rest_flattened(): # 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.CustomMetric.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.get_custom_metric(**mock_args) + client.delete_display_video360_advertiser_link_proposal(**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=properties/*/customMetrics/*}" % client.transport._host, + "%s/v1alpha/{name=properties/*/displayVideo360AdvertiserLinkProposals/*}" + % client.transport._host, args[1], ) -def test_get_custom_metric_rest_flattened_error(transport: str = "rest"): +def test_delete_display_video360_advertiser_link_proposal_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -69060,13 +69138,13 @@ def test_get_custom_metric_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_custom_metric( - analytics_admin.GetCustomMetricRequest(), + client.delete_display_video360_advertiser_link_proposal( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest(), name="name_value", ) -def test_get_data_retention_settings_rest_use_cached_wrapped_rpc(): +def test_approve_display_video360_advertiser_link_proposal_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: @@ -69081,7 +69159,7 @@ def test_get_data_retention_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_data_retention_settings + client._transport.approve_display_video360_advertiser_link_proposal in client._transport._wrapped_methods ) @@ -69091,24 +69169,24 @@ def test_get_data_retention_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_data_retention_settings + client._transport.approve_display_video360_advertiser_link_proposal ] = mock_rpc request = {} - client.get_data_retention_settings(request) + client.approve_display_video360_advertiser_link_proposal(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_data_retention_settings(request) + client.approve_display_video360_advertiser_link_proposal(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_data_retention_settings_rest_required_fields( - request_type=analytics_admin.GetDataRetentionSettingsRequest, +def test_approve_display_video360_advertiser_link_proposal_rest_required_fields( + request_type=analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -69124,7 +69202,9 @@ def test_get_data_retention_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_retention_settings._get_unset_required_fields(jsonified_request) + ).approve_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -69133,7 +69213,9 @@ def test_get_data_retention_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_retention_settings._get_unset_required_fields(jsonified_request) + ).approve_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -69147,7 +69229,9 @@ def test_get_data_retention_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataRetentionSettings() + return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + ) # 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 @@ -69159,97 +69243,46 @@ def test_get_data_retention_settings_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.DataRetentionSettings.pb(return_value) + return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse.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_data_retention_settings(request) + response = client.approve_display_video360_advertiser_link_proposal(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_data_retention_settings_rest_unset_required_fields(): +def test_approve_display_video360_advertiser_link_proposal_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_data_retention_settings._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_get_data_retention_settings_rest_flattened(): - client = AnalyticsAdminServiceClient( - 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.DataRetentionSettings() - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/dataRetentionSettings"} - - # 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.DataRetentionSettings.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_data_retention_settings(**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=properties/*/dataRetentionSettings}" - % client.transport._host, - args[1], - ) - - -def test_get_data_retention_settings_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + unset_fields = transport.approve_display_video360_advertiser_link_proposal._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_data_retention_settings( - analytics_admin.GetDataRetentionSettingsRequest(), - name="name_value", - ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_data_retention_settings_rest_use_cached_wrapped_rpc(): +def test_cancel_display_video360_advertiser_link_proposal_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: @@ -69264,7 +69297,7 @@ def test_update_data_retention_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_data_retention_settings + client._transport.cancel_display_video360_advertiser_link_proposal in client._transport._wrapped_methods ) @@ -69274,28 +69307,29 @@ def test_update_data_retention_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_data_retention_settings + client._transport.cancel_display_video360_advertiser_link_proposal ] = mock_rpc request = {} - client.update_data_retention_settings(request) + client.cancel_display_video360_advertiser_link_proposal(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_data_retention_settings(request) + client.cancel_display_video360_advertiser_link_proposal(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_data_retention_settings_rest_required_fields( - request_type=analytics_admin.UpdateDataRetentionSettingsRequest, +def test_cancel_display_video360_advertiser_link_proposal_rest_required_fields( + request_type=analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -69306,19 +69340,25 @@ def test_update_data_retention_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_data_retention_settings._get_unset_required_fields(jsonified_request) + ).cancel_display_video360_advertiser_link_proposal._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_data_retention_settings._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",)) + ).cancel_display_video360_advertiser_link_proposal._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -69327,7 +69367,7 @@ def test_update_data_retention_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataRetentionSettings() + return_value = resources.DisplayVideo360AdvertiserLinkProposal() # 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 @@ -69339,7 +69379,7 @@ def test_update_data_retention_settings_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "post", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -69349,120 +69389,51 @@ def test_update_data_retention_settings_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRetentionSettings.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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_data_retention_settings(request) + response = client.cancel_display_video360_advertiser_link_proposal(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_data_retention_settings_rest_unset_required_fields(): +def test_cancel_display_video360_advertiser_link_proposal_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_data_retention_settings._get_unset_required_fields( + unset_fields = transport.cancel_display_video360_advertiser_link_proposal._get_unset_required_fields( {} ) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "dataRetentionSettings", - "updateMask", - ) - ) - ) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_data_retention_settings_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_create_custom_dimension_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 = AnalyticsAdminServiceClient( + 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.DataRetentionSettings() + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # get arguments that satisfy an http rule for this method - sample_request = { - "data_retention_settings": { - "name": "properties/sample1/dataRetentionSettings" - } - } - - # get truthy value for each flattened field - mock_args = dict( - data_retention_settings=resources.DataRetentionSettings(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 = resources.DataRetentionSettings.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.update_data_retention_settings(**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/{data_retention_settings.name=properties/*/dataRetentionSettings}" - % client.transport._host, - args[1], - ) - - -def test_update_data_retention_settings_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_data_retention_settings( - analytics_admin.UpdateDataRetentionSettingsRequest(), - data_retention_settings=resources.DataRetentionSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) - - -def test_create_data_stream_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 = AnalyticsAdminServiceClient( - 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_data_stream in client._transport._wrapped_methods - ) + # Ensure method has been cached + assert ( + client._transport.create_custom_dimension + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -69470,24 +69441,24 @@ def test_create_data_stream_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_data_stream + client._transport.create_custom_dimension ] = mock_rpc request = {} - client.create_data_stream(request) + client.create_custom_dimension(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_data_stream(request) + client.create_custom_dimension(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_data_stream_rest_required_fields( - request_type=analytics_admin.CreateDataStreamRequest, +def test_create_custom_dimension_rest_required_fields( + request_type=analytics_admin.CreateCustomDimensionRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -69503,7 +69474,7 @@ def test_create_data_stream_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_data_stream._get_unset_required_fields(jsonified_request) + ).create_custom_dimension._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -69512,7 +69483,7 @@ def test_create_data_stream_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_data_stream._get_unset_required_fields(jsonified_request) + ).create_custom_dimension._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -69526,7 +69497,7 @@ def test_create_data_stream_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataStream() + return_value = resources.CustomDimension() # 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 @@ -69548,38 +69519,38 @@ def test_create_data_stream_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataStream.pb(return_value) + return_value = resources.CustomDimension.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.create_data_stream(request) + response = client.create_custom_dimension(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_data_stream_rest_unset_required_fields(): +def test_create_custom_dimension_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_data_stream._get_unset_required_fields({}) + unset_fields = transport.create_custom_dimension._get_unset_required_fields({}) assert set(unset_fields) == ( set(()) & set( ( "parent", - "dataStream", + "customDimension", ) ) ) -def test_create_data_stream_rest_flattened(): +def test_create_custom_dimension_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -69588,7 +69559,7 @@ def test_create_data_stream_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.DataStream() + return_value = resources.CustomDimension() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -69596,11 +69567,7 @@ def test_create_data_stream_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", - data_stream=resources.DataStream( - web_stream_data=resources.DataStream.WebStreamData( - measurement_id="measurement_id_value" - ) - ), + custom_dimension=resources.CustomDimension(name="name_value"), ) mock_args.update(sample_request) @@ -69608,25 +69575,26 @@ def test_create_data_stream_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataStream.pb(return_value) + return_value = resources.CustomDimension.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_data_stream(**mock_args) + client.create_custom_dimension(**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=properties/*}/dataStreams" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/customDimensions" + % client.transport._host, args[1], ) -def test_create_data_stream_rest_flattened_error(transport: str = "rest"): +def test_create_custom_dimension_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -69635,194 +69603,14 @@ def test_create_data_stream_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_data_stream( - analytics_admin.CreateDataStreamRequest(), + client.create_custom_dimension( + analytics_admin.CreateCustomDimensionRequest(), parent="parent_value", - data_stream=resources.DataStream( - web_stream_data=resources.DataStream.WebStreamData( - measurement_id="measurement_id_value" - ) - ), - ) - - -def test_delete_data_stream_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 = AnalyticsAdminServiceClient( - 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_data_stream 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_data_stream - ] = mock_rpc - - request = {} - client.delete_data_stream(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.delete_data_stream(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_data_stream_rest_required_fields( - request_type=analytics_admin.DeleteDataStreamRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - - 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_data_stream._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_data_stream._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 = AnalyticsAdminServiceClient( - 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_data_stream(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_delete_data_stream_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.delete_data_stream._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_delete_data_stream_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/dataStreams/sample2"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - - client.delete_data_stream(**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=properties/*/dataStreams/*}" % client.transport._host, - args[1], - ) - - -def test_delete_data_stream_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_data_stream( - analytics_admin.DeleteDataStreamRequest(), - name="name_value", + custom_dimension=resources.CustomDimension(name="name_value"), ) -def test_update_data_stream_rest_use_cached_wrapped_rpc(): +def test_update_custom_dimension_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: @@ -69837,7 +69625,8 @@ def test_update_data_stream_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_data_stream in client._transport._wrapped_methods + client._transport.update_custom_dimension + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -69846,24 +69635,24 @@ def test_update_data_stream_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_data_stream + client._transport.update_custom_dimension ] = mock_rpc request = {} - client.update_data_stream(request) + client.update_custom_dimension(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_data_stream(request) + client.update_custom_dimension(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_data_stream_rest_required_fields( - request_type=analytics_admin.UpdateDataStreamRequest, +def test_update_custom_dimension_rest_required_fields( + request_type=analytics_admin.UpdateCustomDimensionRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -69878,14 +69667,14 @@ def test_update_data_stream_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_data_stream._get_unset_required_fields(jsonified_request) + ).update_custom_dimension._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_data_stream._get_unset_required_fields(jsonified_request) + ).update_custom_dimension._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) @@ -69899,7 +69688,7 @@ def test_update_data_stream_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataStream() + return_value = resources.CustomDimension() # 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 @@ -69921,30 +69710,30 @@ def test_update_data_stream_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataStream.pb(return_value) + return_value = resources.CustomDimension.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_data_stream(request) + response = client.update_custom_dimension(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_data_stream_rest_unset_required_fields(): +def test_update_custom_dimension_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_data_stream._get_unset_required_fields({}) + unset_fields = transport.update_custom_dimension._get_unset_required_fields({}) assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) -def test_update_data_stream_rest_flattened(): +def test_update_custom_dimension_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -69953,20 +69742,16 @@ def test_update_data_stream_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.DataStream() + return_value = resources.CustomDimension() # get arguments that satisfy an http rule for this method sample_request = { - "data_stream": {"name": "properties/sample1/dataStreams/sample2"} + "custom_dimension": {"name": "properties/sample1/customDimensions/sample2"} } # get truthy value for each flattened field mock_args = dict( - data_stream=resources.DataStream( - web_stream_data=resources.DataStream.WebStreamData( - measurement_id="measurement_id_value" - ) - ), + custom_dimension=resources.CustomDimension(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -69975,26 +69760,26 @@ def test_update_data_stream_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataStream.pb(return_value) + return_value = resources.CustomDimension.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.update_data_stream(**mock_args) + client.update_custom_dimension(**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/{data_stream.name=properties/*/dataStreams/*}" + "%s/v1alpha/{custom_dimension.name=properties/*/customDimensions/*}" % client.transport._host, args[1], ) -def test_update_data_stream_rest_flattened_error(transport: str = "rest"): +def test_update_custom_dimension_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -70003,18 +69788,14 @@ def test_update_data_stream_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_data_stream( - analytics_admin.UpdateDataStreamRequest(), - data_stream=resources.DataStream( - web_stream_data=resources.DataStream.WebStreamData( - measurement_id="measurement_id_value" - ) - ), + client.update_custom_dimension( + analytics_admin.UpdateCustomDimensionRequest(), + custom_dimension=resources.CustomDimension(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_list_data_streams_rest_use_cached_wrapped_rpc(): +def test_list_custom_dimensions_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: @@ -70028,7 +69809,10 @@ def test_list_data_streams_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_data_streams in client._transport._wrapped_methods + assert ( + client._transport.list_custom_dimensions + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -70036,24 +69820,24 @@ def test_list_data_streams_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_data_streams + client._transport.list_custom_dimensions ] = mock_rpc request = {} - client.list_data_streams(request) + client.list_custom_dimensions(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_data_streams(request) + client.list_custom_dimensions(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_data_streams_rest_required_fields( - request_type=analytics_admin.ListDataStreamsRequest, +def test_list_custom_dimensions_rest_required_fields( + request_type=analytics_admin.ListCustomDimensionsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -70069,7 +69853,7 @@ def test_list_data_streams_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_data_streams._get_unset_required_fields(jsonified_request) + ).list_custom_dimensions._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -70078,7 +69862,7 @@ def test_list_data_streams_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_data_streams._get_unset_required_fields(jsonified_request) + ).list_custom_dimensions._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( @@ -70099,7 +69883,7 @@ def test_list_data_streams_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListDataStreamsResponse() + return_value = analytics_admin.ListCustomDimensionsResponse() # 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 @@ -70120,26 +69904,26 @@ def test_list_data_streams_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListDataStreamsResponse.pb(return_value) + return_value = analytics_admin.ListCustomDimensionsResponse.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_data_streams(request) + response = client.list_custom_dimensions(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_data_streams_rest_unset_required_fields(): +def test_list_custom_dimensions_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_data_streams._get_unset_required_fields({}) + unset_fields = transport.list_custom_dimensions._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( @@ -70151,7 +69935,7 @@ def test_list_data_streams_rest_unset_required_fields(): ) -def test_list_data_streams_rest_flattened(): +def test_list_custom_dimensions_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -70160,7 +69944,7 @@ def test_list_data_streams_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 = analytics_admin.ListDataStreamsResponse() + return_value = analytics_admin.ListCustomDimensionsResponse() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -70175,25 +69959,26 @@ def test_list_data_streams_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListDataStreamsResponse.pb(return_value) + return_value = analytics_admin.ListCustomDimensionsResponse.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_data_streams(**mock_args) + client.list_custom_dimensions(**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=properties/*}/dataStreams" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/customDimensions" + % client.transport._host, args[1], ) -def test_list_data_streams_rest_flattened_error(transport: str = "rest"): +def test_list_custom_dimensions_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -70202,13 +69987,13 @@ def test_list_data_streams_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_data_streams( - analytics_admin.ListDataStreamsRequest(), + client.list_custom_dimensions( + analytics_admin.ListCustomDimensionsRequest(), parent="parent_value", ) -def test_list_data_streams_rest_pager(transport: str = "rest"): +def test_list_custom_dimensions_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -70220,28 +70005,28 @@ def test_list_data_streams_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListDataStreamsResponse( - data_streams=[ - resources.DataStream(), - resources.DataStream(), - resources.DataStream(), + analytics_admin.ListCustomDimensionsResponse( + custom_dimensions=[ + resources.CustomDimension(), + resources.CustomDimension(), + resources.CustomDimension(), ], next_page_token="abc", ), - analytics_admin.ListDataStreamsResponse( - data_streams=[], + analytics_admin.ListCustomDimensionsResponse( + custom_dimensions=[], next_page_token="def", ), - analytics_admin.ListDataStreamsResponse( - data_streams=[ - resources.DataStream(), + analytics_admin.ListCustomDimensionsResponse( + custom_dimensions=[ + resources.CustomDimension(), ], next_page_token="ghi", ), - analytics_admin.ListDataStreamsResponse( - data_streams=[ - resources.DataStream(), - resources.DataStream(), + analytics_admin.ListCustomDimensionsResponse( + custom_dimensions=[ + resources.CustomDimension(), + resources.CustomDimension(), ], ), ) @@ -70250,7 +70035,7 @@ def test_list_data_streams_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListDataStreamsResponse.to_json(x) for x in response + analytics_admin.ListCustomDimensionsResponse.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): @@ -70260,18 +70045,18 @@ def test_list_data_streams_rest_pager(transport: str = "rest"): sample_request = {"parent": "properties/sample1"} - pager = client.list_data_streams(request=sample_request) + pager = client.list_custom_dimensions(request=sample_request) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.DataStream) for i in results) + assert all(isinstance(i, resources.CustomDimension) for i in results) - pages = list(client.list_data_streams(request=sample_request).pages) + pages = list(client.list_custom_dimensions(request=sample_request).pages) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_get_data_stream_rest_use_cached_wrapped_rpc(): +def test_archive_custom_dimension_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: @@ -70285,30 +70070,35 @@ def test_get_data_stream_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_data_stream in client._transport._wrapped_methods + assert ( + client._transport.archive_custom_dimension + 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_data_stream] = mock_rpc + client._transport._wrapped_methods[ + client._transport.archive_custom_dimension + ] = mock_rpc request = {} - client.get_data_stream(request) + client.archive_custom_dimension(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_data_stream(request) + client.archive_custom_dimension(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_data_stream_rest_required_fields( - request_type=analytics_admin.GetDataStreamRequest, +def test_archive_custom_dimension_rest_required_fields( + request_type=analytics_admin.ArchiveCustomDimensionRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -70324,7 +70114,7 @@ def test_get_data_stream_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_stream._get_unset_required_fields(jsonified_request) + ).archive_custom_dimension._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -70333,7 +70123,7 @@ def test_get_data_stream_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_stream._get_unset_required_fields(jsonified_request) + ).archive_custom_dimension._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -70347,7 +70137,7 @@ def test_get_data_stream_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataStream() + 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 @@ -70359,39 +70149,37 @@ def test_get_data_stream_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.DataStream.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"} - response = client.get_data_stream(request) + response = client.archive_custom_dimension(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_data_stream_rest_unset_required_fields(): +def test_archive_custom_dimension_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_data_stream._get_unset_required_fields({}) + unset_fields = transport.archive_custom_dimension._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_data_stream_rest_flattened(): +def test_archive_custom_dimension_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -70400,10 +70188,10 @@ def test_get_data_stream_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.DataStream() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/dataStreams/sample2"} + sample_request = {"name": "properties/sample1/customDimensions/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -70414,26 +70202,25 @@ def test_get_data_stream_rest_flattened(): # 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.DataStream.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.get_data_stream(**mock_args) + client.archive_custom_dimension(**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=properties/*/dataStreams/*}" % client.transport._host, + "%s/v1alpha/{name=properties/*/customDimensions/*}:archive" + % client.transport._host, args[1], ) -def test_get_data_stream_rest_flattened_error(transport: str = "rest"): +def test_archive_custom_dimension_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -70442,13 +70229,13 @@ def test_get_data_stream_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_data_stream( - analytics_admin.GetDataStreamRequest(), + client.archive_custom_dimension( + analytics_admin.ArchiveCustomDimensionRequest(), name="name_value", ) -def test_get_audience_rest_use_cached_wrapped_rpc(): +def test_get_custom_dimension_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: @@ -70462,30 +70249,34 @@ def test_get_audience_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_audience in client._transport._wrapped_methods + assert ( + client._transport.get_custom_dimension 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_audience] = mock_rpc + client._transport._wrapped_methods[ + client._transport.get_custom_dimension + ] = mock_rpc request = {} - client.get_audience(request) + client.get_custom_dimension(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_audience(request) + client.get_custom_dimension(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_audience_rest_required_fields( - request_type=analytics_admin.GetAudienceRequest, +def test_get_custom_dimension_rest_required_fields( + request_type=analytics_admin.GetCustomDimensionRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -70501,7 +70292,7 @@ def test_get_audience_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_audience._get_unset_required_fields(jsonified_request) + ).get_custom_dimension._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -70510,7 +70301,7 @@ def test_get_audience_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_audience._get_unset_required_fields(jsonified_request) + ).get_custom_dimension._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -70524,7 +70315,7 @@ def test_get_audience_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = audience.Audience() + return_value = resources.CustomDimension() # 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 @@ -70545,30 +70336,30 @@ def test_get_audience_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = audience.Audience.pb(return_value) + return_value = resources.CustomDimension.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_audience(request) + response = client.get_custom_dimension(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_audience_rest_unset_required_fields(): +def test_get_custom_dimension_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_audience._get_unset_required_fields({}) + unset_fields = transport.get_custom_dimension._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_audience_rest_flattened(): +def test_get_custom_dimension_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -70577,10 +70368,10 @@ def test_get_audience_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 = audience.Audience() + return_value = resources.CustomDimension() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/audiences/sample2"} + sample_request = {"name": "properties/sample1/customDimensions/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -70592,25 +70383,26 @@ def test_get_audience_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = audience.Audience.pb(return_value) + return_value = resources.CustomDimension.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_audience(**mock_args) + client.get_custom_dimension(**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=properties/*/audiences/*}" % client.transport._host, + "%s/v1alpha/{name=properties/*/customDimensions/*}" + % client.transport._host, args[1], ) -def test_get_audience_rest_flattened_error(transport: str = "rest"): +def test_get_custom_dimension_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -70619,13 +70411,13 @@ def test_get_audience_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_audience( - analytics_admin.GetAudienceRequest(), + client.get_custom_dimension( + analytics_admin.GetCustomDimensionRequest(), name="name_value", ) -def test_list_audiences_rest_use_cached_wrapped_rpc(): +def test_create_custom_metric_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: @@ -70639,30 +70431,34 @@ def test_list_audiences_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_audiences in client._transport._wrapped_methods + assert ( + client._transport.create_custom_metric 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_audiences] = mock_rpc + client._transport._wrapped_methods[ + client._transport.create_custom_metric + ] = mock_rpc request = {} - client.list_audiences(request) + client.create_custom_metric(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_audiences(request) + client.create_custom_metric(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_audiences_rest_required_fields( - request_type=analytics_admin.ListAudiencesRequest, +def test_create_custom_metric_rest_required_fields( + request_type=analytics_admin.CreateCustomMetricRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -70678,7 +70474,7 @@ def test_list_audiences_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_audiences._get_unset_required_fields(jsonified_request) + ).create_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -70687,14 +70483,7 @@ def test_list_audiences_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_audiences._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).create_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -70708,7 +70497,7 @@ def test_list_audiences_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListAudiencesResponse() + return_value = resources.CustomMetric() # 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 @@ -70720,47 +70509,48 @@ def test_list_audiences_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 = analytics_admin.ListAudiencesResponse.pb(return_value) + return_value = resources.CustomMetric.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_audiences(request) + response = client.create_custom_metric(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_audiences_rest_unset_required_fields(): +def test_create_custom_metric_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_audiences._get_unset_required_fields({}) + unset_fields = transport.create_custom_metric._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "pageSize", - "pageToken", + "parent", + "customMetric", ) ) - & set(("parent",)) ) -def test_list_audiences_rest_flattened(): +def test_create_custom_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -70769,7 +70559,7 @@ def test_list_audiences_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 = analytics_admin.ListAudiencesResponse() + return_value = resources.CustomMetric() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -70777,6 +70567,7 @@ def test_list_audiences_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", + custom_metric=resources.CustomMetric(name="name_value"), ) mock_args.update(sample_request) @@ -70784,25 +70575,25 @@ def test_list_audiences_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAudiencesResponse.pb(return_value) + return_value = resources.CustomMetric.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_audiences(**mock_args) + client.create_custom_metric(**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=properties/*}/audiences" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/customMetrics" % client.transport._host, args[1], ) -def test_list_audiences_rest_flattened_error(transport: str = "rest"): +def test_create_custom_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -70811,76 +70602,14 @@ def test_list_audiences_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_audiences( - analytics_admin.ListAudiencesRequest(), + client.create_custom_metric( + analytics_admin.CreateCustomMetricRequest(), parent="parent_value", + custom_metric=resources.CustomMetric(name="name_value"), ) -def test_list_audiences_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListAudiencesResponse( - audiences=[ - audience.Audience(), - audience.Audience(), - audience.Audience(), - ], - next_page_token="abc", - ), - analytics_admin.ListAudiencesResponse( - audiences=[], - next_page_token="def", - ), - analytics_admin.ListAudiencesResponse( - audiences=[ - audience.Audience(), - ], - next_page_token="ghi", - ), - analytics_admin.ListAudiencesResponse( - audiences=[ - audience.Audience(), - audience.Audience(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListAudiencesResponse.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": "properties/sample1"} - - pager = client.list_audiences(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, audience.Audience) for i in results) - - pages = list(client.list_audiences(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_create_audience_rest_use_cached_wrapped_rpc(): +def test_update_custom_metric_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: @@ -70894,35 +70623,38 @@ def test_create_audience_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_audience in client._transport._wrapped_methods + assert ( + client._transport.update_custom_metric 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_audience] = mock_rpc + client._transport._wrapped_methods[ + client._transport.update_custom_metric + ] = mock_rpc request = {} - client.create_audience(request) + client.update_custom_metric(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_audience(request) + client.update_custom_metric(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_audience_rest_required_fields( - request_type=analytics_admin.CreateAudienceRequest, +def test_update_custom_metric_rest_required_fields( + request_type=analytics_admin.UpdateCustomMetricRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -70933,21 +70665,19 @@ def test_create_audience_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_audience._get_unset_required_fields(jsonified_request) + ).update_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_audience._get_unset_required_fields(jsonified_request) + ).update_custom_metric._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -70956,7 +70686,7 @@ def test_create_audience_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_audience.Audience() + return_value = resources.CustomMetric() # 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 @@ -70968,7 +70698,7 @@ def test_create_audience_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -70978,38 +70708,30 @@ def test_create_audience_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_audience.Audience.pb(return_value) + return_value = resources.CustomMetric.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.create_audience(request) + response = client.update_custom_metric(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_audience_rest_unset_required_fields(): +def test_update_custom_metric_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_audience._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "audience", - ) - ) - ) + unset_fields = transport.update_custom_metric._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) -def test_create_audience_rest_flattened(): +def test_update_custom_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -71018,15 +70740,17 @@ def test_create_audience_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 = gaa_audience.Audience() + return_value = resources.CustomMetric() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "custom_metric": {"name": "properties/sample1/customMetrics/sample2"} + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - audience=gaa_audience.Audience(name="name_value"), + custom_metric=resources.CustomMetric(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -71034,25 +70758,26 @@ def test_create_audience_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_audience.Audience.pb(return_value) + return_value = resources.CustomMetric.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_audience(**mock_args) + client.update_custom_metric(**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=properties/*}/audiences" % client.transport._host, + "%s/v1alpha/{custom_metric.name=properties/*/customMetrics/*}" + % client.transport._host, args[1], ) -def test_create_audience_rest_flattened_error(transport: str = "rest"): +def test_update_custom_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -71061,14 +70786,14 @@ def test_create_audience_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_audience( - analytics_admin.CreateAudienceRequest(), - parent="parent_value", - audience=gaa_audience.Audience(name="name_value"), + client.update_custom_metric( + analytics_admin.UpdateCustomMetricRequest(), + custom_metric=resources.CustomMetric(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_audience_rest_use_cached_wrapped_rpc(): +def test_list_custom_metrics_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: @@ -71082,34 +70807,39 @@ def test_update_audience_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_audience in client._transport._wrapped_methods + assert ( + client._transport.list_custom_metrics 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_audience] = mock_rpc + client._transport._wrapped_methods[ + client._transport.list_custom_metrics + ] = mock_rpc request = {} - client.update_audience(request) + client.list_custom_metrics(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_audience(request) + client.list_custom_metrics(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_audience_rest_required_fields( - request_type=analytics_admin.UpdateAudienceRequest, +def test_list_custom_metrics_rest_required_fields( + request_type=analytics_admin.ListCustomMetricsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -71120,19 +70850,28 @@ def test_update_audience_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_audience._get_unset_required_fields(jsonified_request) + ).list_custom_metrics._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_audience._get_unset_required_fields(jsonified_request) + ).list_custom_metrics._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( + ( + "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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -71141,7 +70880,7 @@ def test_update_audience_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_audience.Audience() + return_value = analytics_admin.ListCustomMetricsResponse() # 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 @@ -71153,48 +70892,47 @@ def test_update_audience_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 = gaa_audience.Audience.pb(return_value) + return_value = analytics_admin.ListCustomMetricsResponse.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_audience(request) + response = client.list_custom_metrics(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_audience_rest_unset_required_fields(): +def test_list_custom_metrics_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_audience._get_unset_required_fields({}) + unset_fields = transport.list_custom_metrics._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) - & set( + set( ( - "audience", - "updateMask", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_update_audience_rest_flattened(): +def test_list_custom_metrics_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -71203,15 +70941,14 @@ def test_update_audience_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 = gaa_audience.Audience() + return_value = analytics_admin.ListCustomMetricsResponse() # get arguments that satisfy an http rule for this method - sample_request = {"audience": {"name": "properties/sample1/audiences/sample2"}} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - audience=gaa_audience.Audience(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", ) mock_args.update(sample_request) @@ -71219,26 +70956,25 @@ def test_update_audience_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_audience.Audience.pb(return_value) + return_value = analytics_admin.ListCustomMetricsResponse.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.update_audience(**mock_args) + client.list_custom_metrics(**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/{audience.name=properties/*/audiences/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/customMetrics" % client.transport._host, args[1], ) -def test_update_audience_rest_flattened_error(transport: str = "rest"): +def test_list_custom_metrics_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -71247,14 +70983,76 @@ def test_update_audience_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_audience( - analytics_admin.UpdateAudienceRequest(), - audience=gaa_audience.Audience(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.list_custom_metrics( + analytics_admin.ListCustomMetricsRequest(), + parent="parent_value", ) -def test_archive_audience_rest_use_cached_wrapped_rpc(): +def test_list_custom_metrics_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListCustomMetricsResponse( + custom_metrics=[ + resources.CustomMetric(), + resources.CustomMetric(), + resources.CustomMetric(), + ], + next_page_token="abc", + ), + analytics_admin.ListCustomMetricsResponse( + custom_metrics=[], + next_page_token="def", + ), + analytics_admin.ListCustomMetricsResponse( + custom_metrics=[ + resources.CustomMetric(), + ], + next_page_token="ghi", + ), + analytics_admin.ListCustomMetricsResponse( + custom_metrics=[ + resources.CustomMetric(), + resources.CustomMetric(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListCustomMetricsResponse.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": "properties/sample1"} + + pager = client.list_custom_metrics(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.CustomMetric) for i in results) + + pages = list(client.list_custom_metrics(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_archive_custom_metric_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: @@ -71268,7 +71066,10 @@ def test_archive_audience_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.archive_audience in client._transport._wrapped_methods + assert ( + client._transport.archive_custom_metric + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -71276,24 +71077,24 @@ def test_archive_audience_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.archive_audience + client._transport.archive_custom_metric ] = mock_rpc request = {} - client.archive_audience(request) + client.archive_custom_metric(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.archive_audience(request) + client.archive_custom_metric(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_archive_audience_rest_required_fields( - request_type=analytics_admin.ArchiveAudienceRequest, +def test_archive_custom_metric_rest_required_fields( + request_type=analytics_admin.ArchiveCustomMetricRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -71309,7 +71110,7 @@ def test_archive_audience_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).archive_audience._get_unset_required_fields(jsonified_request) + ).archive_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -71318,7 +71119,7 @@ def test_archive_audience_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).archive_audience._get_unset_required_fields(jsonified_request) + ).archive_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -71358,23 +71159,79 @@ def test_archive_audience_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.archive_audience(request) + response = client.archive_custom_metric(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_archive_audience_rest_unset_required_fields(): +def test_archive_custom_metric_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.archive_audience._get_unset_required_fields({}) + unset_fields = transport.archive_custom_metric._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_search_ads360_link_rest_use_cached_wrapped_rpc(): +def test_archive_custom_metric_rest_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/customMetrics/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.archive_custom_metric(**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=properties/*/customMetrics/*}:archive" + % client.transport._host, + args[1], + ) + + +def test_archive_custom_metric_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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.archive_custom_metric( + analytics_admin.ArchiveCustomMetricRequest(), + name="name_value", + ) + + +def test_get_custom_metric_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: @@ -71388,10 +71245,7 @@ def test_get_search_ads360_link_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_search_ads360_link - in client._transport._wrapped_methods - ) + assert client._transport.get_custom_metric in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -71399,24 +71253,24 @@ def test_get_search_ads360_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_search_ads360_link + client._transport.get_custom_metric ] = mock_rpc request = {} - client.get_search_ads360_link(request) + client.get_custom_metric(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_search_ads360_link(request) + client.get_custom_metric(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_search_ads360_link_rest_required_fields( - request_type=analytics_admin.GetSearchAds360LinkRequest, +def test_get_custom_metric_rest_required_fields( + request_type=analytics_admin.GetCustomMetricRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -71432,7 +71286,7 @@ def test_get_search_ads360_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_search_ads360_link._get_unset_required_fields(jsonified_request) + ).get_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -71441,7 +71295,7 @@ def test_get_search_ads360_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_search_ads360_link._get_unset_required_fields(jsonified_request) + ).get_custom_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -71455,7 +71309,7 @@ def test_get_search_ads360_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.SearchAds360Link() + return_value = resources.CustomMetric() # 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 @@ -71476,30 +71330,30 @@ def test_get_search_ads360_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SearchAds360Link.pb(return_value) + return_value = resources.CustomMetric.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_search_ads360_link(request) + response = client.get_custom_metric(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_search_ads360_link_rest_unset_required_fields(): +def test_get_custom_metric_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_search_ads360_link._get_unset_required_fields({}) + unset_fields = transport.get_custom_metric._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_search_ads360_link_rest_flattened(): +def test_get_custom_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -71508,10 +71362,10 @@ def test_get_search_ads360_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.SearchAds360Link() + return_value = resources.CustomMetric() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/searchAds360Links/sample2"} + sample_request = {"name": "properties/sample1/customMetrics/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -71523,26 +71377,25 @@ def test_get_search_ads360_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SearchAds360Link.pb(return_value) + return_value = resources.CustomMetric.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_search_ads360_link(**mock_args) + client.get_custom_metric(**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=properties/*/searchAds360Links/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/customMetrics/*}" % client.transport._host, args[1], ) -def test_get_search_ads360_link_rest_flattened_error(transport: str = "rest"): +def test_get_custom_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -71551,13 +71404,13 @@ def test_get_search_ads360_link_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_search_ads360_link( - analytics_admin.GetSearchAds360LinkRequest(), + client.get_custom_metric( + analytics_admin.GetCustomMetricRequest(), name="name_value", ) -def test_list_search_ads360_links_rest_use_cached_wrapped_rpc(): +def test_get_data_retention_settings_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: @@ -71572,7 +71425,7 @@ def test_list_search_ads360_links_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_search_ads360_links + client._transport.get_data_retention_settings in client._transport._wrapped_methods ) @@ -71582,29 +71435,29 @@ def test_list_search_ads360_links_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_search_ads360_links + client._transport.get_data_retention_settings ] = mock_rpc request = {} - client.list_search_ads360_links(request) + client.get_data_retention_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_search_ads360_links(request) + client.get_data_retention_settings(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_search_ads360_links_rest_required_fields( - request_type=analytics_admin.ListSearchAds360LinksRequest, +def test_get_data_retention_settings_rest_required_fields( + request_type=analytics_admin.GetDataRetentionSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -71615,28 +71468,21 @@ def test_list_search_ads360_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_search_ads360_links._get_unset_required_fields(jsonified_request) + ).get_data_retention_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_search_ads360_links._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).get_data_retention_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -71645,7 +71491,7 @@ def test_list_search_ads360_links_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListSearchAds360LinksResponse() + return_value = resources.DataRetentionSettings() # 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 @@ -71666,40 +71512,30 @@ def test_list_search_ads360_links_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListSearchAds360LinksResponse.pb( - return_value - ) + return_value = resources.DataRetentionSettings.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_search_ads360_links(request) + response = client.get_data_retention_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_search_ads360_links_rest_unset_required_fields(): +def test_get_data_retention_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_search_ads360_links._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.get_data_retention_settings._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_search_ads360_links_rest_flattened(): +def test_get_data_retention_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -71708,14 +71544,14 @@ def test_list_search_ads360_links_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 = analytics_admin.ListSearchAds360LinksResponse() + return_value = resources.DataRetentionSettings() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"name": "properties/sample1/dataRetentionSettings"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) @@ -71723,26 +71559,26 @@ def test_list_search_ads360_links_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListSearchAds360LinksResponse.pb(return_value) + return_value = resources.DataRetentionSettings.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_search_ads360_links(**mock_args) + client.get_data_retention_settings(**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=properties/*}/searchAds360Links" + "%s/v1alpha/{name=properties/*/dataRetentionSettings}" % client.transport._host, args[1], ) -def test_list_search_ads360_links_rest_flattened_error(transport: str = "rest"): +def test_get_data_retention_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -71751,76 +71587,13 @@ def test_list_search_ads360_links_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_search_ads360_links( - analytics_admin.ListSearchAds360LinksRequest(), - parent="parent_value", - ) - - -def test_list_search_ads360_links_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListSearchAds360LinksResponse( - search_ads_360_links=[ - resources.SearchAds360Link(), - resources.SearchAds360Link(), - resources.SearchAds360Link(), - ], - next_page_token="abc", - ), - analytics_admin.ListSearchAds360LinksResponse( - search_ads_360_links=[], - next_page_token="def", - ), - analytics_admin.ListSearchAds360LinksResponse( - search_ads_360_links=[ - resources.SearchAds360Link(), - ], - next_page_token="ghi", - ), - analytics_admin.ListSearchAds360LinksResponse( - search_ads_360_links=[ - resources.SearchAds360Link(), - resources.SearchAds360Link(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListSearchAds360LinksResponse.to_json(x) for x in response + client.get_data_retention_settings( + analytics_admin.GetDataRetentionSettingsRequest(), + name="name_value", ) - 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": "properties/sample1"} - - pager = client.list_search_ads360_links(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.SearchAds360Link) for i in results) - - pages = list(client.list_search_ads360_links(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_create_search_ads360_link_rest_use_cached_wrapped_rpc(): +def test_update_data_retention_settings_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: @@ -71835,7 +71608,7 @@ def test_create_search_ads360_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_search_ads360_link + client._transport.update_data_retention_settings in client._transport._wrapped_methods ) @@ -71845,29 +71618,28 @@ def test_create_search_ads360_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_search_ads360_link + client._transport.update_data_retention_settings ] = mock_rpc request = {} - client.create_search_ads360_link(request) + client.update_data_retention_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_search_ads360_link(request) + client.update_data_retention_settings(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_search_ads360_link_rest_required_fields( - request_type=analytics_admin.CreateSearchAds360LinkRequest, +def test_update_data_retention_settings_rest_required_fields( + request_type=analytics_admin.UpdateDataRetentionSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -71878,21 +71650,19 @@ def test_create_search_ads360_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_search_ads360_link._get_unset_required_fields(jsonified_request) + ).update_data_retention_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_search_ads360_link._get_unset_required_fields(jsonified_request) + ).update_data_retention_settings._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -71901,7 +71671,7 @@ def test_create_search_ads360_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.SearchAds360Link() + return_value = resources.DataRetentionSettings() # 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 @@ -71913,7 +71683,7 @@ def test_create_search_ads360_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -71923,38 +71693,40 @@ def test_create_search_ads360_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SearchAds360Link.pb(return_value) + return_value = resources.DataRetentionSettings.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.create_search_ads360_link(request) + response = client.update_data_retention_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_search_ads360_link_rest_unset_required_fields(): +def test_update_data_retention_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_search_ads360_link._get_unset_required_fields({}) + unset_fields = transport.update_data_retention_settings._get_unset_required_fields( + {} + ) assert set(unset_fields) == ( - set(()) + set(("updateMask",)) & set( ( - "parent", - "searchAds360Link", + "dataRetentionSettings", + "updateMask", ) ) ) -def test_create_search_ads360_link_rest_flattened(): +def test_update_data_retention_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -71963,15 +71735,19 @@ def test_create_search_ads360_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.SearchAds360Link() + return_value = resources.DataRetentionSettings() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "data_retention_settings": { + "name": "properties/sample1/dataRetentionSettings" + } + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - search_ads_360_link=resources.SearchAds360Link(name="name_value"), + data_retention_settings=resources.DataRetentionSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -71979,26 +71755,26 @@ def test_create_search_ads360_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SearchAds360Link.pb(return_value) + return_value = resources.DataRetentionSettings.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_search_ads360_link(**mock_args) + client.update_data_retention_settings(**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=properties/*}/searchAds360Links" + "%s/v1alpha/{data_retention_settings.name=properties/*/dataRetentionSettings}" % client.transport._host, args[1], ) -def test_create_search_ads360_link_rest_flattened_error(transport: str = "rest"): +def test_update_data_retention_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -72007,14 +71783,14 @@ def test_create_search_ads360_link_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_search_ads360_link( - analytics_admin.CreateSearchAds360LinkRequest(), - parent="parent_value", - search_ads_360_link=resources.SearchAds360Link(name="name_value"), + client.update_data_retention_settings( + analytics_admin.UpdateDataRetentionSettingsRequest(), + data_retention_settings=resources.DataRetentionSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_search_ads360_link_rest_use_cached_wrapped_rpc(): +def test_create_data_stream_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: @@ -72029,8 +71805,7 @@ def test_delete_search_ads360_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_search_ads360_link - in client._transport._wrapped_methods + client._transport.create_data_stream in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -72039,29 +71814,29 @@ def test_delete_search_ads360_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_search_ads360_link + client._transport.create_data_stream ] = mock_rpc request = {} - client.delete_search_ads360_link(request) + client.create_data_stream(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_search_ads360_link(request) + client.create_data_stream(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_search_ads360_link_rest_required_fields( - request_type=analytics_admin.DeleteSearchAds360LinkRequest, +def test_create_data_stream_rest_required_fields( + request_type=analytics_admin.CreateDataStreamRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -72072,21 +71847,21 @@ def test_delete_search_ads360_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_search_ads360_link._get_unset_required_fields(jsonified_request) + ).create_data_stream._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_search_ads360_link._get_unset_required_fields(jsonified_request) + ).create_data_stream._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -72095,7 +71870,7 @@ def test_delete_search_ads360_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.DataStream() # 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 @@ -72107,36 +71882,48 @@ def test_delete_search_ads360_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 = resources.DataStream.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_search_ads360_link(request) + response = client.create_data_stream(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_search_ads360_link_rest_unset_required_fields(): +def test_create_data_stream_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_search_ads360_link._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_data_stream._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "dataStream", + ) + ) + ) -def test_delete_search_ads360_link_rest_flattened(): +def test_create_data_stream_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -72145,39 +71932,45 @@ def test_delete_search_ads360_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 = resources.DataStream() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/searchAds360Links/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + data_stream=resources.DataStream( + web_stream_data=resources.DataStream.WebStreamData( + measurement_id="measurement_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 = "" + # Convert return value to protobuf type + return_value = resources.DataStream.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_search_ads360_link(**mock_args) + client.create_data_stream(**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=properties/*/searchAds360Links/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/dataStreams" % client.transport._host, args[1], ) -def test_delete_search_ads360_link_rest_flattened_error(transport: str = "rest"): +def test_create_data_stream_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -72186,13 +71979,18 @@ def test_delete_search_ads360_link_rest_flattened_error(transport: str = "rest") # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_search_ads360_link( - analytics_admin.DeleteSearchAds360LinkRequest(), - name="name_value", + client.create_data_stream( + analytics_admin.CreateDataStreamRequest(), + parent="parent_value", + data_stream=resources.DataStream( + web_stream_data=resources.DataStream.WebStreamData( + measurement_id="measurement_id_value" + ) + ), ) -def test_update_search_ads360_link_rest_use_cached_wrapped_rpc(): +def test_delete_data_stream_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: @@ -72207,8 +72005,7 @@ def test_update_search_ads360_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_search_ads360_link - in client._transport._wrapped_methods + client._transport.delete_data_stream in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -72217,28 +72014,29 @@ def test_update_search_ads360_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_search_ads360_link + client._transport.delete_data_stream ] = mock_rpc request = {} - client.update_search_ads360_link(request) + client.delete_data_stream(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_search_ads360_link(request) + client.delete_data_stream(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_search_ads360_link_rest_required_fields( - request_type=analytics_admin.UpdateSearchAds360LinkRequest, +def test_delete_data_stream_rest_required_fields( + request_type=analytics_admin.DeleteDataStreamRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -72249,19 +72047,21 @@ def test_update_search_ads360_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_search_ads360_link._get_unset_required_fields(jsonified_request) + ).delete_data_stream._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_search_ads360_link._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",)) + ).delete_data_stream._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -72270,7 +72070,7 @@ def test_update_search_ads360_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.SearchAds360Link() + 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 @@ -72282,40 +72082,36 @@ def test_update_search_ads360_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = resources.SearchAds360Link.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"} - response = client.update_search_ads360_link(request) + response = client.delete_data_stream(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_search_ads360_link_rest_unset_required_fields(): +def test_delete_data_stream_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_search_ads360_link._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) + unset_fields = transport.delete_data_stream._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_search_ads360_link_rest_flattened(): +def test_delete_data_stream_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -72324,46 +72120,38 @@ def test_update_search_ads360_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.SearchAds360Link() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "search_ads_360_link": { - "name": "properties/sample1/searchAds360Links/sample2" - } - } + sample_request = {"name": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - search_ads_360_link=resources.SearchAds360Link(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_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.SearchAds360Link.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.update_search_ads360_link(**mock_args) + client.delete_data_stream(**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/{search_ads_360_link.name=properties/*/searchAds360Links/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/dataStreams/*}" % client.transport._host, args[1], ) -def test_update_search_ads360_link_rest_flattened_error(transport: str = "rest"): +def test_delete_data_stream_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -72372,14 +72160,13 @@ def test_update_search_ads360_link_rest_flattened_error(transport: str = "rest") # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_search_ads360_link( - analytics_admin.UpdateSearchAds360LinkRequest(), - search_ads_360_link=resources.SearchAds360Link(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.delete_data_stream( + analytics_admin.DeleteDataStreamRequest(), + name="name_value", ) -def test_get_attribution_settings_rest_use_cached_wrapped_rpc(): +def test_update_data_stream_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: @@ -72394,8 +72181,7 @@ def test_get_attribution_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_attribution_settings - in client._transport._wrapped_methods + client._transport.update_data_stream in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -72404,29 +72190,28 @@ def test_get_attribution_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_attribution_settings + client._transport.update_data_stream ] = mock_rpc request = {} - client.get_attribution_settings(request) + client.update_data_stream(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_attribution_settings(request) + client.update_data_stream(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_attribution_settings_rest_required_fields( - request_type=analytics_admin.GetAttributionSettingsRequest, +def test_update_data_stream_rest_required_fields( + request_type=analytics_admin.UpdateDataStreamRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -72437,21 +72222,19 @@ def test_get_attribution_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_attribution_settings._get_unset_required_fields(jsonified_request) + ).update_data_stream._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_attribution_settings._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + ).update_data_stream._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -72460,7 +72243,7 @@ def test_get_attribution_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AttributionSettings() + return_value = resources.DataStream() # 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 @@ -72472,39 +72255,40 @@ def test_get_attribution_settings_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 = resources.AttributionSettings.pb(return_value) + return_value = resources.DataStream.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_attribution_settings(request) + response = client.update_data_stream(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_attribution_settings_rest_unset_required_fields(): +def test_update_data_stream_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_attribution_settings._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.update_data_stream._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) -def test_get_attribution_settings_rest_flattened(): +def test_update_data_stream_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -72513,14 +72297,21 @@ def test_get_attribution_settings_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.AttributionSettings() + return_value = resources.DataStream() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/attributionSettings"} + sample_request = { + "data_stream": {"name": "properties/sample1/dataStreams/sample2"} + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + data_stream=resources.DataStream( + web_stream_data=resources.DataStream.WebStreamData( + measurement_id="measurement_id_value" + ) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -72528,26 +72319,26 @@ def test_get_attribution_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AttributionSettings.pb(return_value) + return_value = resources.DataStream.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_attribution_settings(**mock_args) + client.update_data_stream(**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=properties/*/attributionSettings}" + "%s/v1alpha/{data_stream.name=properties/*/dataStreams/*}" % client.transport._host, args[1], ) -def test_get_attribution_settings_rest_flattened_error(transport: str = "rest"): +def test_update_data_stream_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -72556,13 +72347,18 @@ def test_get_attribution_settings_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_attribution_settings( - analytics_admin.GetAttributionSettingsRequest(), - name="name_value", + client.update_data_stream( + analytics_admin.UpdateDataStreamRequest(), + data_stream=resources.DataStream( + web_stream_data=resources.DataStream.WebStreamData( + measurement_id="measurement_id_value" + ) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_attribution_settings_rest_use_cached_wrapped_rpc(): +def test_list_data_streams_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: @@ -72576,10 +72372,7 @@ def test_update_attribution_settings_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_attribution_settings - in client._transport._wrapped_methods - ) + assert client._transport.list_data_streams in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -72587,28 +72380,29 @@ def test_update_attribution_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_attribution_settings + client._transport.list_data_streams ] = mock_rpc request = {} - client.update_attribution_settings(request) + client.list_data_streams(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_attribution_settings(request) + client.list_data_streams(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_attribution_settings_rest_required_fields( - request_type=analytics_admin.UpdateAttributionSettingsRequest, +def test_list_data_streams_rest_required_fields( + request_type=analytics_admin.ListDataStreamsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -72619,19 +72413,28 @@ def test_update_attribution_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_attribution_settings._get_unset_required_fields(jsonified_request) + ).list_data_streams._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_attribution_settings._get_unset_required_fields(jsonified_request) + ).list_data_streams._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( + ( + "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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -72640,7 +72443,7 @@ def test_update_attribution_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AttributionSettings() + return_value = analytics_admin.ListDataStreamsResponse() # 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 @@ -72652,48 +72455,47 @@ def test_update_attribution_settings_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 = resources.AttributionSettings.pb(return_value) + return_value = analytics_admin.ListDataStreamsResponse.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_attribution_settings(request) + response = client.list_data_streams(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_attribution_settings_rest_unset_required_fields(): +def test_list_data_streams_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_attribution_settings._get_unset_required_fields({}) + unset_fields = transport.list_data_streams._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) - & set( + set( ( - "attributionSettings", - "updateMask", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_update_attribution_settings_rest_flattened(): +def test_list_data_streams_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -72702,17 +72504,14 @@ def test_update_attribution_settings_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.AttributionSettings() + return_value = analytics_admin.ListDataStreamsResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "attribution_settings": {"name": "properties/sample1/attributionSettings"} - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - attribution_settings=resources.AttributionSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", ) mock_args.update(sample_request) @@ -72720,26 +72519,25 @@ def test_update_attribution_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AttributionSettings.pb(return_value) + return_value = analytics_admin.ListDataStreamsResponse.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.update_attribution_settings(**mock_args) + client.list_data_streams(**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/{attribution_settings.name=properties/*/attributionSettings}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/dataStreams" % client.transport._host, args[1], ) -def test_update_attribution_settings_rest_flattened_error(transport: str = "rest"): +def test_list_data_streams_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -72748,52 +72546,76 @@ def test_update_attribution_settings_rest_flattened_error(transport: str = "rest # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_attribution_settings( - analytics_admin.UpdateAttributionSettingsRequest(), - attribution_settings=resources.AttributionSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.list_data_streams( + analytics_admin.ListDataStreamsRequest(), + parent="parent_value", ) -def test_run_access_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +def test_list_data_streams_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - # Ensure method has been cached - assert client._transport.run_access_report in client._transport._wrapped_methods + # 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 = ( + analytics_admin.ListDataStreamsResponse( + data_streams=[ + resources.DataStream(), + resources.DataStream(), + resources.DataStream(), + ], + next_page_token="abc", + ), + analytics_admin.ListDataStreamsResponse( + data_streams=[], + next_page_token="def", + ), + analytics_admin.ListDataStreamsResponse( + data_streams=[ + resources.DataStream(), + ], + next_page_token="ghi", + ), + analytics_admin.ListDataStreamsResponse( + data_streams=[ + resources.DataStream(), + resources.DataStream(), + ], + ), + ) + # Two responses for two calls + response = response + response - # 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. + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListDataStreamsResponse.to_json(x) for x in response ) - client._transport._wrapped_methods[ - client._transport.run_access_report - ] = mock_rpc + 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 - request = {} - client.run_access_report(request) + sample_request = {"parent": "properties/sample1"} - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 + pager = client.list_data_streams(request=sample_request) - client.run_access_report(request) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.DataStream) for i in results) - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + pages = list(client.list_data_streams(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_create_access_binding_rest_use_cached_wrapped_rpc(): +def test_get_data_stream_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: @@ -72807,40 +72629,35 @@ def test_create_access_binding_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.create_access_binding - in client._transport._wrapped_methods - ) + assert client._transport.get_data_stream 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_access_binding - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_data_stream] = mock_rpc request = {} - client.create_access_binding(request) + client.get_data_stream(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_access_binding(request) + client.get_data_stream(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_access_binding_rest_required_fields( - request_type=analytics_admin.CreateAccessBindingRequest, +def test_get_data_stream_rest_required_fields( + request_type=analytics_admin.GetDataStreamRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -72851,21 +72668,21 @@ def test_create_access_binding_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_access_binding._get_unset_required_fields(jsonified_request) + ).get_data_stream._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_access_binding._get_unset_required_fields(jsonified_request) + ).get_data_stream._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -72874,7 +72691,7 @@ def test_create_access_binding_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AccessBinding() + return_value = resources.DataStream() # 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 @@ -72886,48 +72703,39 @@ def test_create_access_binding_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = resources.DataStream.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.create_access_binding(request) + response = client.get_data_stream(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_access_binding_rest_unset_required_fields(): +def test_get_data_stream_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_access_binding._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "accessBinding", - ) - ) - ) + unset_fields = transport.get_data_stream._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_access_binding_rest_flattened(): +def test_get_data_stream_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -72936,15 +72744,14 @@ def test_create_access_binding_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.AccessBinding() + return_value = resources.DataStream() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "accounts/sample1"} + sample_request = {"name": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - access_binding=resources.AccessBinding(user="user_value"), + name="name_value", ) mock_args.update(sample_request) @@ -72952,25 +72759,25 @@ def test_create_access_binding_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = resources.DataStream.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_access_binding(**mock_args) + client.get_data_stream(**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=accounts/*}/accessBindings" % client.transport._host, + "%s/v1alpha/{name=properties/*/dataStreams/*}" % client.transport._host, args[1], ) -def test_create_access_binding_rest_flattened_error(transport: str = "rest"): +def test_get_data_stream_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -72979,14 +72786,13 @@ def test_create_access_binding_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_access_binding( - analytics_admin.CreateAccessBindingRequest(), - parent="parent_value", - access_binding=resources.AccessBinding(user="user_value"), + client.get_data_stream( + analytics_admin.GetDataStreamRequest(), + name="name_value", ) -def test_get_access_binding_rest_use_cached_wrapped_rpc(): +def test_get_audience_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: @@ -73000,34 +72806,30 @@ def test_get_access_binding_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_access_binding in client._transport._wrapped_methods - ) + assert client._transport.get_audience 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_access_binding - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_audience] = mock_rpc request = {} - client.get_access_binding(request) + client.get_audience(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_access_binding(request) + client.get_audience(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_access_binding_rest_required_fields( - request_type=analytics_admin.GetAccessBindingRequest, +def test_get_audience_rest_required_fields( + request_type=analytics_admin.GetAudienceRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -73043,7 +72845,7 @@ def test_get_access_binding_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_access_binding._get_unset_required_fields(jsonified_request) + ).get_audience._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -73052,7 +72854,7 @@ def test_get_access_binding_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_access_binding._get_unset_required_fields(jsonified_request) + ).get_audience._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -73066,7 +72868,7 @@ def test_get_access_binding_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AccessBinding() + return_value = audience.Audience() # 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 @@ -73087,30 +72889,30 @@ def test_get_access_binding_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = audience.Audience.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_access_binding(request) + response = client.get_audience(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_access_binding_rest_unset_required_fields(): +def test_get_audience_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_access_binding._get_unset_required_fields({}) + unset_fields = transport.get_audience._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_access_binding_rest_flattened(): +def test_get_audience_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -73119,10 +72921,10 @@ def test_get_access_binding_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.AccessBinding() + return_value = audience.Audience() # get arguments that satisfy an http rule for this method - sample_request = {"name": "accounts/sample1/accessBindings/sample2"} + sample_request = {"name": "properties/sample1/audiences/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -73134,25 +72936,25 @@ def test_get_access_binding_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = audience.Audience.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_access_binding(**mock_args) + client.get_audience(**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=accounts/*/accessBindings/*}" % client.transport._host, + "%s/v1alpha/{name=properties/*/audiences/*}" % client.transport._host, args[1], ) -def test_get_access_binding_rest_flattened_error(transport: str = "rest"): +def test_get_audience_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -73161,13 +72963,13 @@ def test_get_access_binding_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_access_binding( - analytics_admin.GetAccessBindingRequest(), + client.get_audience( + analytics_admin.GetAudienceRequest(), name="name_value", ) -def test_update_access_binding_rest_use_cached_wrapped_rpc(): +def test_list_audiences_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: @@ -73181,39 +72983,35 @@ def test_update_access_binding_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_access_binding - in client._transport._wrapped_methods - ) + assert client._transport.list_audiences 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_access_binding - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_audiences] = mock_rpc request = {} - client.update_access_binding(request) + client.list_audiences(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_access_binding(request) + client.list_audiences(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_access_binding_rest_required_fields( - request_type=analytics_admin.UpdateAccessBindingRequest, +def test_list_audiences_rest_required_fields( + request_type=analytics_admin.ListAudiencesRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -73224,17 +73022,28 @@ def test_update_access_binding_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_access_binding._get_unset_required_fields(jsonified_request) + ).list_audiences._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_access_binding._get_unset_required_fields(jsonified_request) + ).list_audiences._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -73243,7 +73052,7 @@ def test_update_access_binding_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AccessBinding() + return_value = analytics_admin.ListAudiencesResponse() # 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 @@ -73255,40 +73064,47 @@ def test_update_access_binding_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 = resources.AccessBinding.pb(return_value) + return_value = analytics_admin.ListAudiencesResponse.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_access_binding(request) + response = client.list_audiences(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_access_binding_rest_unset_required_fields(): +def test_list_audiences_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_access_binding._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("accessBinding",))) + unset_fields = transport.list_audiences._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_update_access_binding_rest_flattened(): +def test_list_audiences_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -73297,16 +73113,14 @@ def test_update_access_binding_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.AccessBinding() + return_value = analytics_admin.ListAudiencesResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "access_binding": {"name": "accounts/sample1/accessBindings/sample2"} - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - access_binding=resources.AccessBinding(user="user_value"), + parent="parent_value", ) mock_args.update(sample_request) @@ -73314,26 +73128,25 @@ def test_update_access_binding_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = analytics_admin.ListAudiencesResponse.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.update_access_binding(**mock_args) + client.list_audiences(**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/{access_binding.name=accounts/*/accessBindings/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/audiences" % client.transport._host, args[1], ) -def test_update_access_binding_rest_flattened_error(transport: str = "rest"): +def test_list_audiences_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -73342,13 +73155,76 @@ def test_update_access_binding_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_access_binding( - analytics_admin.UpdateAccessBindingRequest(), - access_binding=resources.AccessBinding(user="user_value"), + client.list_audiences( + analytics_admin.ListAudiencesRequest(), + parent="parent_value", ) -def test_delete_access_binding_rest_use_cached_wrapped_rpc(): +def test_list_audiences_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListAudiencesResponse( + audiences=[ + audience.Audience(), + audience.Audience(), + audience.Audience(), + ], + next_page_token="abc", + ), + analytics_admin.ListAudiencesResponse( + audiences=[], + next_page_token="def", + ), + analytics_admin.ListAudiencesResponse( + audiences=[ + audience.Audience(), + ], + next_page_token="ghi", + ), + analytics_admin.ListAudiencesResponse( + audiences=[ + audience.Audience(), + audience.Audience(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListAudiencesResponse.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": "properties/sample1"} + + pager = client.list_audiences(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, audience.Audience) for i in results) + + pages = list(client.list_audiences(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_audience_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: @@ -73362,40 +73238,35 @@ def test_delete_access_binding_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_access_binding - in client._transport._wrapped_methods - ) + assert client._transport.create_audience 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_access_binding - ] = mock_rpc + client._transport._wrapped_methods[client._transport.create_audience] = mock_rpc request = {} - client.delete_access_binding(request) + client.create_audience(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_access_binding(request) + client.create_audience(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_access_binding_rest_required_fields( - request_type=analytics_admin.DeleteAccessBindingRequest, +def test_create_audience_rest_required_fields( + request_type=analytics_admin.CreateAudienceRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -73406,21 +73277,21 @@ def test_delete_access_binding_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_access_binding._get_unset_required_fields(jsonified_request) + ).create_audience._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_access_binding._get_unset_required_fields(jsonified_request) + ).create_audience._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -73429,7 +73300,7 @@ def test_delete_access_binding_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = gaa_audience.Audience() # 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 @@ -73441,36 +73312,48 @@ def test_delete_access_binding_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 = gaa_audience.Audience.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_access_binding(request) + response = client.create_audience(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_access_binding_rest_unset_required_fields(): +def test_create_audience_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_access_binding._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_audience._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "audience", + ) + ) + ) -def test_delete_access_binding_rest_flattened(): +def test_create_audience_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -73479,38 +73362,41 @@ def test_delete_access_binding_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 = gaa_audience.Audience() # get arguments that satisfy an http rule for this method - sample_request = {"name": "accounts/sample1/accessBindings/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + audience=gaa_audience.Audience(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 = "" + # Convert return value to protobuf type + return_value = gaa_audience.Audience.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_access_binding(**mock_args) + client.create_audience(**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=accounts/*/accessBindings/*}" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/audiences" % client.transport._host, args[1], ) -def test_delete_access_binding_rest_flattened_error(transport: str = "rest"): +def test_create_audience_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -73519,13 +73405,14 @@ def test_delete_access_binding_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_access_binding( - analytics_admin.DeleteAccessBindingRequest(), - name="name_value", + client.create_audience( + analytics_admin.CreateAudienceRequest(), + parent="parent_value", + audience=gaa_audience.Audience(name="name_value"), ) -def test_list_access_bindings_rest_use_cached_wrapped_rpc(): +def test_update_audience_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: @@ -73539,39 +73426,34 @@ def test_list_access_bindings_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_access_bindings in client._transport._wrapped_methods - ) + assert client._transport.update_audience 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_access_bindings - ] = mock_rpc + client._transport._wrapped_methods[client._transport.update_audience] = mock_rpc request = {} - client.list_access_bindings(request) + client.update_audience(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_access_bindings(request) + client.update_audience(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_access_bindings_rest_required_fields( - request_type=analytics_admin.ListAccessBindingsRequest, +def test_update_audience_rest_required_fields( + request_type=analytics_admin.UpdateAudienceRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -73582,28 +73464,19 @@ def test_list_access_bindings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_access_bindings._get_unset_required_fields(jsonified_request) + ).update_audience._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_access_bindings._get_unset_required_fields(jsonified_request) + ).update_audience._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + assert not set(unset_fields) - set(("update_mask",)) 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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -73612,7 +73485,7 @@ def test_list_access_bindings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListAccessBindingsResponse() + return_value = gaa_audience.Audience() # 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 @@ -73624,47 +73497,48 @@ def test_list_access_bindings_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 = analytics_admin.ListAccessBindingsResponse.pb(return_value) + return_value = gaa_audience.Audience.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_access_bindings(request) + response = client.update_audience(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_access_bindings_rest_unset_required_fields(): +def test_update_audience_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_access_bindings._get_unset_required_fields({}) + unset_fields = transport.update_audience._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(("updateMask",)) + & set( ( - "pageSize", - "pageToken", + "audience", + "updateMask", ) ) - & set(("parent",)) ) -def test_list_access_bindings_rest_flattened(): +def test_update_audience_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -73673,14 +73547,15 @@ def test_list_access_bindings_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 = analytics_admin.ListAccessBindingsResponse() + return_value = gaa_audience.Audience() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "accounts/sample1"} + sample_request = {"audience": {"name": "properties/sample1/audiences/sample2"}} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + audience=gaa_audience.Audience(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -73688,25 +73563,26 @@ def test_list_access_bindings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAccessBindingsResponse.pb(return_value) + return_value = gaa_audience.Audience.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_access_bindings(**mock_args) + client.update_audience(**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=accounts/*}/accessBindings" % client.transport._host, + "%s/v1alpha/{audience.name=properties/*/audiences/*}" + % client.transport._host, args[1], ) -def test_list_access_bindings_rest_flattened_error(transport: str = "rest"): +def test_update_audience_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -73715,76 +73591,14 @@ def test_list_access_bindings_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_access_bindings( - analytics_admin.ListAccessBindingsRequest(), - parent="parent_value", - ) - - -def test_list_access_bindings_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListAccessBindingsResponse( - access_bindings=[ - resources.AccessBinding(), - resources.AccessBinding(), - resources.AccessBinding(), - ], - next_page_token="abc", - ), - analytics_admin.ListAccessBindingsResponse( - access_bindings=[], - next_page_token="def", - ), - analytics_admin.ListAccessBindingsResponse( - access_bindings=[ - resources.AccessBinding(), - ], - next_page_token="ghi", - ), - analytics_admin.ListAccessBindingsResponse( - access_bindings=[ - resources.AccessBinding(), - resources.AccessBinding(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListAccessBindingsResponse.to_json(x) for x in response + client.update_audience( + analytics_admin.UpdateAudienceRequest(), + audience=gaa_audience.Audience(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) - 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": "accounts/sample1"} - - pager = client.list_access_bindings(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.AccessBinding) for i in results) - - pages = list(client.list_access_bindings(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_batch_create_access_bindings_rest_use_cached_wrapped_rpc(): +def test_archive_audience_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: @@ -73798,10 +73612,7 @@ def test_batch_create_access_bindings_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.batch_create_access_bindings - in client._transport._wrapped_methods - ) + assert client._transport.archive_audience in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -73809,29 +73620,29 @@ def test_batch_create_access_bindings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.batch_create_access_bindings + client._transport.archive_audience ] = mock_rpc request = {} - client.batch_create_access_bindings(request) + client.archive_audience(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.batch_create_access_bindings(request) + client.archive_audience(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_batch_create_access_bindings_rest_required_fields( - request_type=analytics_admin.BatchCreateAccessBindingsRequest, +def test_archive_audience_rest_required_fields( + request_type=analytics_admin.ArchiveAudienceRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -73842,21 +73653,21 @@ def test_batch_create_access_bindings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).batch_create_access_bindings._get_unset_required_fields(jsonified_request) + ).archive_audience._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).batch_create_access_bindings._get_unset_required_fields(jsonified_request) + ).archive_audience._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -73865,7 +73676,7 @@ def test_batch_create_access_bindings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.BatchCreateAccessBindingsResponse() + 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 @@ -73885,42 +73696,29 @@ def test_batch_create_access_bindings_rest_required_fields( response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = analytics_admin.BatchCreateAccessBindingsResponse.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"} - response = client.batch_create_access_bindings(request) + response = client.archive_audience(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_batch_create_access_bindings_rest_unset_required_fields(): +def test_archive_audience_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.batch_create_access_bindings._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "requests", - ) - ) - ) + unset_fields = transport.archive_audience._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_batch_get_access_bindings_rest_use_cached_wrapped_rpc(): +def test_get_search_ads360_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: @@ -73935,7 +73733,7 @@ def test_batch_get_access_bindings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.batch_get_access_bindings + client._transport.get_search_ads360_link in client._transport._wrapped_methods ) @@ -73945,30 +73743,29 @@ def test_batch_get_access_bindings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.batch_get_access_bindings + client._transport.get_search_ads360_link ] = mock_rpc request = {} - client.batch_get_access_bindings(request) + client.get_search_ads360_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.batch_get_access_bindings(request) + client.get_search_ads360_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_batch_get_access_bindings_rest_required_fields( - request_type=analytics_admin.BatchGetAccessBindingsRequest, +def test_get_search_ads360_link_rest_required_fields( + request_type=analytics_admin.GetSearchAds360LinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" - request_init["names"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -73976,32 +73773,24 @@ def test_batch_get_access_bindings_rest_required_fields( ) # verify fields with default values are dropped - assert "names" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).batch_get_access_bindings._get_unset_required_fields(jsonified_request) + ).get_search_ads360_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "names" in jsonified_request - assert jsonified_request["names"] == request_init["names"] - jsonified_request["parent"] = "parent_value" - jsonified_request["names"] = "names_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).batch_get_access_bindings._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("names",)) + ).get_search_ads360_link._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 "names" in jsonified_request - assert jsonified_request["names"] == "names_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -74010,7 +73799,7 @@ def test_batch_get_access_bindings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.BatchGetAccessBindingsResponse() + return_value = resources.SearchAds360Link() # 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 @@ -74031,46 +73820,88 @@ def test_batch_get_access_bindings_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.BatchGetAccessBindingsResponse.pb( - return_value - ) + return_value = resources.SearchAds360Link.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.batch_get_access_bindings(request) + response = client.get_search_ads360_link(request) - expected_params = [ - ( - "names", - "", - ), - ("$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_batch_get_access_bindings_rest_unset_required_fields(): +def test_get_search_ads360_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.batch_get_access_bindings._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("names",)) - & set( - ( - "parent", - "names", - ) + unset_fields = transport.get_search_ads360_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_search_ads360_link_rest_flattened(): + client = AnalyticsAdminServiceClient( + 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.SearchAds360Link() + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/searchAds360Links/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.SearchAds360Link.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_search_ads360_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/{name=properties/*/searchAds360Links/*}" + % client.transport._host, + args[1], ) + + +def test_get_search_ads360_link_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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_search_ads360_link( + analytics_admin.GetSearchAds360LinkRequest(), + name="name_value", + ) + -def test_batch_update_access_bindings_rest_use_cached_wrapped_rpc(): +def test_list_search_ads360_links_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: @@ -74085,7 +73916,7 @@ def test_batch_update_access_bindings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.batch_update_access_bindings + client._transport.list_search_ads360_links in client._transport._wrapped_methods ) @@ -74095,24 +73926,24 @@ def test_batch_update_access_bindings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.batch_update_access_bindings + client._transport.list_search_ads360_links ] = mock_rpc request = {} - client.batch_update_access_bindings(request) + client.list_search_ads360_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.batch_update_access_bindings(request) + client.list_search_ads360_links(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_batch_update_access_bindings_rest_required_fields( - request_type=analytics_admin.BatchUpdateAccessBindingsRequest, +def test_list_search_ads360_links_rest_required_fields( + request_type=analytics_admin.ListSearchAds360LinksRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -74128,7 +73959,7 @@ def test_batch_update_access_bindings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).batch_update_access_bindings._get_unset_required_fields(jsonified_request) + ).list_search_ads360_links._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -74137,7 +73968,14 @@ def test_batch_update_access_bindings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).batch_update_access_bindings._get_unset_required_fields(jsonified_request) + ).list_search_ads360_links._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -74151,7 +73989,7 @@ def test_batch_update_access_bindings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.BatchUpdateAccessBindingsResponse() + return_value = analytics_admin.ListSearchAds360LinksResponse() # 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 @@ -74163,17 +74001,16 @@ def test_batch_update_access_bindings_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.BatchUpdateAccessBindingsResponse.pb( + return_value = analytics_admin.ListSearchAds360LinksResponse.pb( return_value ) json_return_value = json_format.MessageToJson(return_value) @@ -74182,162 +74019,152 @@ def test_batch_update_access_bindings_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.batch_update_access_bindings(request) + response = client.list_search_ads360_links(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_batch_update_access_bindings_rest_unset_required_fields(): +def test_list_search_ads360_links_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.batch_update_access_bindings._get_unset_required_fields({}) + unset_fields = transport.list_search_ads360_links._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) - & set( + set( ( - "parent", - "requests", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_batch_delete_access_bindings_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_list_search_ads360_links_rest_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() + # 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 = analytics_admin.ListSearchAds360LinksResponse() - # Ensure method has been cached - assert ( - client._transport.batch_delete_access_bindings - in client._transport._wrapped_methods - ) + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} - # 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. + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", ) - client._transport._wrapped_methods[ - client._transport.batch_delete_access_bindings - ] = mock_rpc - - request = {} - client.batch_delete_access_bindings(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 + mock_args.update(sample_request) - client.batch_delete_access_bindings(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 = analytics_admin.ListSearchAds360LinksResponse.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"} - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + client.list_search_ads360_links(**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=properties/*}/searchAds360Links" + % client.transport._host, + args[1], + ) -def test_batch_delete_access_bindings_rest_required_fields( - request_type=analytics_admin.BatchDeleteAccessBindingsRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - 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) +def test_list_search_ads360_links_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).batch_delete_access_bindings._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() - ).batch_delete_access_bindings._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_search_ads360_links( + analytics_admin.ListSearchAds360LinksRequest(), + parent="parent_value", + ) - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" +def test_list_search_ads360_links_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - 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": "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 = "" - - 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"} + # 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 = ( + analytics_admin.ListSearchAds360LinksResponse( + search_ads_360_links=[ + resources.SearchAds360Link(), + resources.SearchAds360Link(), + resources.SearchAds360Link(), + ], + next_page_token="abc", + ), + analytics_admin.ListSearchAds360LinksResponse( + search_ads_360_links=[], + next_page_token="def", + ), + analytics_admin.ListSearchAds360LinksResponse( + search_ads_360_links=[ + resources.SearchAds360Link(), + ], + next_page_token="ghi", + ), + analytics_admin.ListSearchAds360LinksResponse( + search_ads_360_links=[ + resources.SearchAds360Link(), + resources.SearchAds360Link(), + ], + ), + ) + # Two responses for two calls + response = response + response - response = client.batch_delete_access_bindings(request) + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListSearchAds360LinksResponse.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 - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + sample_request = {"parent": "properties/sample1"} + pager = client.list_search_ads360_links(request=sample_request) -def test_batch_delete_access_bindings_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.SearchAds360Link) for i in results) - unset_fields = transport.batch_delete_access_bindings._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "requests", - ) - ) - ) + pages = list(client.list_search_ads360_links(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_get_expanded_data_set_rest_use_cached_wrapped_rpc(): +def test_create_search_ads360_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: @@ -74352,7 +74179,7 @@ def test_get_expanded_data_set_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_expanded_data_set + client._transport.create_search_ads360_link in client._transport._wrapped_methods ) @@ -74362,29 +74189,29 @@ def test_get_expanded_data_set_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_expanded_data_set + client._transport.create_search_ads360_link ] = mock_rpc request = {} - client.get_expanded_data_set(request) + client.create_search_ads360_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_expanded_data_set(request) + client.create_search_ads360_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_get_expanded_data_set_rest_required_fields( - request_type=analytics_admin.GetExpandedDataSetRequest, +def test_create_search_ads360_link_rest_required_fields( + request_type=analytics_admin.CreateSearchAds360LinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -74395,21 +74222,21 @@ def test_get_expanded_data_set_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_expanded_data_set._get_unset_required_fields(jsonified_request) + ).create_search_ads360_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" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_expanded_data_set._get_unset_required_fields(jsonified_request) + ).create_search_ads360_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" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -74418,7 +74245,7 @@ def test_get_expanded_data_set_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = expanded_data_set.ExpandedDataSet() + return_value = resources.SearchAds360Link() # 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 @@ -74430,39 +74257,48 @@ def test_get_expanded_data_set_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 = expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.SearchAds360Link.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_expanded_data_set(request) + response = client.create_search_ads360_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_expanded_data_set_rest_unset_required_fields(): +def test_create_search_ads360_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_expanded_data_set._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_search_ads360_link._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "searchAds360Link", + ) + ) + ) -def test_get_expanded_data_set_rest_flattened(): +def test_create_search_ads360_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -74471,14 +74307,15 @@ def test_get_expanded_data_set_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 = expanded_data_set.ExpandedDataSet() + return_value = resources.SearchAds360Link() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/expandedDataSets/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + search_ads_360_link=resources.SearchAds360Link(name="name_value"), ) mock_args.update(sample_request) @@ -74486,26 +74323,26 @@ def test_get_expanded_data_set_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.SearchAds360Link.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_expanded_data_set(**mock_args) + client.create_search_ads360_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/{name=properties/*/expandedDataSets/*}" + "%s/v1alpha/{parent=properties/*}/searchAds360Links" % client.transport._host, args[1], ) -def test_get_expanded_data_set_rest_flattened_error(transport: str = "rest"): +def test_create_search_ads360_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -74514,13 +74351,14 @@ def test_get_expanded_data_set_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_expanded_data_set( - analytics_admin.GetExpandedDataSetRequest(), - name="name_value", + client.create_search_ads360_link( + analytics_admin.CreateSearchAds360LinkRequest(), + parent="parent_value", + search_ads_360_link=resources.SearchAds360Link(name="name_value"), ) -def test_list_expanded_data_sets_rest_use_cached_wrapped_rpc(): +def test_delete_search_ads360_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: @@ -74535,7 +74373,7 @@ def test_list_expanded_data_sets_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_expanded_data_sets + client._transport.delete_search_ads360_link in client._transport._wrapped_methods ) @@ -74545,29 +74383,29 @@ def test_list_expanded_data_sets_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_expanded_data_sets + client._transport.delete_search_ads360_link ] = mock_rpc request = {} - client.list_expanded_data_sets(request) + client.delete_search_ads360_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_expanded_data_sets(request) + client.delete_search_ads360_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_list_expanded_data_sets_rest_required_fields( - request_type=analytics_admin.ListExpandedDataSetsRequest, +def test_delete_search_ads360_link_rest_required_fields( + request_type=analytics_admin.DeleteSearchAds360LinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -74578,28 +74416,21 @@ def test_list_expanded_data_sets_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_expanded_data_sets._get_unset_required_fields(jsonified_request) + ).delete_search_ads360_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_expanded_data_sets._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).delete_search_ads360_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -74608,7 +74439,7 @@ def test_list_expanded_data_sets_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListExpandedDataSetsResponse() + 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 @@ -74620,47 +74451,36 @@ def test_list_expanded_data_sets_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "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 = analytics_admin.ListExpandedDataSetsResponse.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"} - response = client.list_expanded_data_sets(request) + response = client.delete_search_ads360_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_expanded_data_sets_rest_unset_required_fields(): +def test_delete_search_ads360_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_expanded_data_sets._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.delete_search_ads360_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_expanded_data_sets_rest_flattened(): +def test_delete_search_ads360_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -74669,41 +74489,39 @@ def test_list_expanded_data_sets_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 = analytics_admin.ListExpandedDataSetsResponse() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"name": "properties/sample1/searchAds360Links/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_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 = analytics_admin.ListExpandedDataSetsResponse.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.list_expanded_data_sets(**mock_args) + client.delete_search_ads360_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=properties/*}/expandedDataSets" + "%s/v1alpha/{name=properties/*/searchAds360Links/*}" % client.transport._host, args[1], ) -def test_list_expanded_data_sets_rest_flattened_error(transport: str = "rest"): +def test_delete_search_ads360_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -74712,76 +74530,13 @@ def test_list_expanded_data_sets_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_expanded_data_sets( - analytics_admin.ListExpandedDataSetsRequest(), - parent="parent_value", - ) - - -def test_list_expanded_data_sets_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListExpandedDataSetsResponse( - expanded_data_sets=[ - expanded_data_set.ExpandedDataSet(), - expanded_data_set.ExpandedDataSet(), - expanded_data_set.ExpandedDataSet(), - ], - next_page_token="abc", - ), - analytics_admin.ListExpandedDataSetsResponse( - expanded_data_sets=[], - next_page_token="def", - ), - analytics_admin.ListExpandedDataSetsResponse( - expanded_data_sets=[ - expanded_data_set.ExpandedDataSet(), - ], - next_page_token="ghi", - ), - analytics_admin.ListExpandedDataSetsResponse( - expanded_data_sets=[ - expanded_data_set.ExpandedDataSet(), - expanded_data_set.ExpandedDataSet(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListExpandedDataSetsResponse.to_json(x) for x in response + client.delete_search_ads360_link( + analytics_admin.DeleteSearchAds360LinkRequest(), + name="name_value", ) - 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": "properties/sample1"} - - pager = client.list_expanded_data_sets(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, expanded_data_set.ExpandedDataSet) for i in results) - - pages = list(client.list_expanded_data_sets(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_create_expanded_data_set_rest_use_cached_wrapped_rpc(): +def test_update_search_ads360_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: @@ -74796,7 +74551,7 @@ def test_create_expanded_data_set_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_expanded_data_set + client._transport.update_search_ads360_link in client._transport._wrapped_methods ) @@ -74806,29 +74561,28 @@ def test_create_expanded_data_set_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_expanded_data_set + client._transport.update_search_ads360_link ] = mock_rpc request = {} - client.create_expanded_data_set(request) + client.update_search_ads360_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_expanded_data_set(request) + client.update_search_ads360_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_create_expanded_data_set_rest_required_fields( - request_type=analytics_admin.CreateExpandedDataSetRequest, +def test_update_search_ads360_link_rest_required_fields( + request_type=analytics_admin.UpdateSearchAds360LinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -74839,21 +74593,19 @@ def test_create_expanded_data_set_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_expanded_data_set._get_unset_required_fields(jsonified_request) + ).update_search_ads360_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_expanded_data_set._get_unset_required_fields(jsonified_request) + ).update_search_ads360_link._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -74862,7 +74614,7 @@ def test_create_expanded_data_set_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_expanded_data_set.ExpandedDataSet() + return_value = resources.SearchAds360Link() # 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 @@ -74874,7 +74626,7 @@ def test_create_expanded_data_set_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -74884,38 +74636,30 @@ def test_create_expanded_data_set_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.SearchAds360Link.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.create_expanded_data_set(request) + response = client.update_search_ads360_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_expanded_data_set_rest_unset_required_fields(): +def test_update_search_ads360_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_expanded_data_set._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "expandedDataSet", - ) - ) - ) + unset_fields = transport.update_search_ads360_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("updateMask",))) -def test_create_expanded_data_set_rest_flattened(): +def test_update_search_ads360_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -74924,15 +74668,19 @@ def test_create_expanded_data_set_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 = gaa_expanded_data_set.ExpandedDataSet() + return_value = resources.SearchAds360Link() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "search_ads_360_link": { + "name": "properties/sample1/searchAds360Links/sample2" + } + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), + search_ads_360_link=resources.SearchAds360Link(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -74940,26 +74688,26 @@ def test_create_expanded_data_set_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.SearchAds360Link.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_expanded_data_set(**mock_args) + client.update_search_ads360_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=properties/*}/expandedDataSets" + "%s/v1alpha/{search_ads_360_link.name=properties/*/searchAds360Links/*}" % client.transport._host, args[1], ) -def test_create_expanded_data_set_rest_flattened_error(transport: str = "rest"): +def test_update_search_ads360_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -74968,14 +74716,14 @@ def test_create_expanded_data_set_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_expanded_data_set( - analytics_admin.CreateExpandedDataSetRequest(), - parent="parent_value", - expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), + client.update_search_ads360_link( + analytics_admin.UpdateSearchAds360LinkRequest(), + search_ads_360_link=resources.SearchAds360Link(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_expanded_data_set_rest_use_cached_wrapped_rpc(): +def test_get_attribution_settings_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: @@ -74990,7 +74738,7 @@ def test_update_expanded_data_set_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_expanded_data_set + client._transport.get_attribution_settings in client._transport._wrapped_methods ) @@ -75000,28 +74748,29 @@ def test_update_expanded_data_set_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_expanded_data_set + client._transport.get_attribution_settings ] = mock_rpc request = {} - client.update_expanded_data_set(request) + client.get_attribution_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_expanded_data_set(request) + client.get_attribution_settings(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_expanded_data_set_rest_required_fields( - request_type=analytics_admin.UpdateExpandedDataSetRequest, +def test_get_attribution_settings_rest_required_fields( + request_type=analytics_admin.GetAttributionSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -75032,19 +74781,21 @@ def test_update_expanded_data_set_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_expanded_data_set._get_unset_required_fields(jsonified_request) + ).get_attribution_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_expanded_data_set._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).get_attribution_settings._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -75053,7 +74804,7 @@ def test_update_expanded_data_set_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_expanded_data_set.ExpandedDataSet() + return_value = resources.AttributionSettings() # 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 @@ -75065,48 +74816,39 @@ def test_update_expanded_data_set_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 = gaa_expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.AttributionSettings.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_expanded_data_set(request) + response = client.get_attribution_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_expanded_data_set_rest_unset_required_fields(): +def test_get_attribution_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_expanded_data_set._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "expandedDataSet", - "updateMask", - ) - ) - ) + unset_fields = transport.get_attribution_settings._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_expanded_data_set_rest_flattened(): +def test_get_attribution_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -75115,17 +74857,14 @@ def test_update_expanded_data_set_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 = gaa_expanded_data_set.ExpandedDataSet() + return_value = resources.AttributionSettings() # get arguments that satisfy an http rule for this method - sample_request = { - "expanded_data_set": {"name": "properties/sample1/expandedDataSets/sample2"} - } + sample_request = {"name": "properties/sample1/attributionSettings"} # get truthy value for each flattened field mock_args = dict( - expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) @@ -75133,26 +74872,26 @@ def test_update_expanded_data_set_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.AttributionSettings.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.update_expanded_data_set(**mock_args) + client.get_attribution_settings(**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/{expanded_data_set.name=properties/*/expandedDataSets/*}" + "%s/v1alpha/{name=properties/*/attributionSettings}" % client.transport._host, args[1], ) -def test_update_expanded_data_set_rest_flattened_error(transport: str = "rest"): +def test_get_attribution_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -75161,14 +74900,13 @@ def test_update_expanded_data_set_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_expanded_data_set( - analytics_admin.UpdateExpandedDataSetRequest(), - expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_attribution_settings( + analytics_admin.GetAttributionSettingsRequest(), + name="name_value", ) -def test_delete_expanded_data_set_rest_use_cached_wrapped_rpc(): +def test_update_attribution_settings_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: @@ -75183,7 +74921,7 @@ def test_delete_expanded_data_set_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_expanded_data_set + client._transport.update_attribution_settings in client._transport._wrapped_methods ) @@ -75193,29 +74931,28 @@ def test_delete_expanded_data_set_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_expanded_data_set + client._transport.update_attribution_settings ] = mock_rpc request = {} - client.delete_expanded_data_set(request) + client.update_attribution_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_expanded_data_set(request) + client.update_attribution_settings(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_expanded_data_set_rest_required_fields( - request_type=analytics_admin.DeleteExpandedDataSetRequest, +def test_update_attribution_settings_rest_required_fields( + request_type=analytics_admin.UpdateAttributionSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -75226,21 +74963,19 @@ def test_delete_expanded_data_set_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_expanded_data_set._get_unset_required_fields(jsonified_request) + ).update_attribution_settings._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_expanded_data_set._get_unset_required_fields(jsonified_request) + ).update_attribution_settings._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -75249,7 +74984,7 @@ def test_delete_expanded_data_set_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.AttributionSettings() # 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 @@ -75261,36 +74996,48 @@ def test_delete_expanded_data_set_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "patch", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.AttributionSettings.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_expanded_data_set(request) + response = client.update_attribution_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_expanded_data_set_rest_unset_required_fields(): +def test_update_attribution_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_expanded_data_set._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.update_attribution_settings._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "attributionSettings", + "updateMask", + ) + ) + ) -def test_delete_expanded_data_set_rest_flattened(): +def test_update_attribution_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -75299,39 +75046,44 @@ def test_delete_expanded_data_set_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 = resources.AttributionSettings() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/expandedDataSets/sample2"} + sample_request = { + "attribution_settings": {"name": "properties/sample1/attributionSettings"} + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + attribution_settings=resources.AttributionSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + # Convert return value to protobuf type + return_value = resources.AttributionSettings.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_expanded_data_set(**mock_args) + client.update_attribution_settings(**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=properties/*/expandedDataSets/*}" + "%s/v1alpha/{attribution_settings.name=properties/*/attributionSettings}" % client.transport._host, args[1], ) -def test_delete_expanded_data_set_rest_flattened_error(transport: str = "rest"): +def test_update_attribution_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -75340,13 +75092,14 @@ def test_delete_expanded_data_set_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_expanded_data_set( - analytics_admin.DeleteExpandedDataSetRequest(), - name="name_value", + client.update_attribution_settings( + analytics_admin.UpdateAttributionSettingsRequest(), + attribution_settings=resources.AttributionSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_channel_group_rest_use_cached_wrapped_rpc(): +def test_run_access_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: @@ -75360,7 +75113,7 @@ def test_get_channel_group_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_channel_group in client._transport._wrapped_methods + assert client._transport.run_access_report in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -75368,29 +75121,70 @@ def test_get_channel_group_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_channel_group + client._transport.run_access_report ] = mock_rpc request = {} - client.get_channel_group(request) + client.run_access_report(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_channel_group(request) + client.run_access_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_get_channel_group_rest_required_fields( - request_type=analytics_admin.GetChannelGroupRequest, +def test_create_access_binding_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 = AnalyticsAdminServiceClient( + 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_access_binding + 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_access_binding + ] = mock_rpc + + request = {} + client.create_access_binding(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.create_access_binding(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_access_binding_rest_required_fields( + request_type=analytics_admin.CreateAccessBindingRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -75401,21 +75195,21 @@ def test_get_channel_group_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_channel_group._get_unset_required_fields(jsonified_request) + ).create_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_channel_group._get_unset_required_fields(jsonified_request) + ).create_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -75424,7 +75218,7 @@ def test_get_channel_group_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = channel_group.ChannelGroup() + return_value = resources.AccessBinding() # 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 @@ -75436,39 +75230,48 @@ def test_get_channel_group_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 = channel_group.ChannelGroup.pb(return_value) + return_value = resources.AccessBinding.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_channel_group(request) + response = client.create_access_binding(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_channel_group_rest_unset_required_fields(): +def test_create_access_binding_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_channel_group._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_access_binding._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "accessBinding", + ) + ) + ) -def test_get_channel_group_rest_flattened(): +def test_create_access_binding_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -75477,14 +75280,15 @@ def test_get_channel_group_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 = channel_group.ChannelGroup() + return_value = resources.AccessBinding() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/channelGroups/sample2"} + sample_request = {"parent": "accounts/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + access_binding=resources.AccessBinding(user="user_value"), ) mock_args.update(sample_request) @@ -75492,25 +75296,25 @@ def test_get_channel_group_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = channel_group.ChannelGroup.pb(return_value) + return_value = resources.AccessBinding.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_channel_group(**mock_args) + client.create_access_binding(**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=properties/*/channelGroups/*}" % client.transport._host, + "%s/v1alpha/{parent=accounts/*}/accessBindings" % client.transport._host, args[1], ) -def test_get_channel_group_rest_flattened_error(transport: str = "rest"): +def test_create_access_binding_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -75519,13 +75323,14 @@ def test_get_channel_group_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_channel_group( - analytics_admin.GetChannelGroupRequest(), - name="name_value", + client.create_access_binding( + analytics_admin.CreateAccessBindingRequest(), + parent="parent_value", + access_binding=resources.AccessBinding(user="user_value"), ) -def test_list_channel_groups_rest_use_cached_wrapped_rpc(): +def test_get_access_binding_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: @@ -75540,7 +75345,7 @@ def test_list_channel_groups_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_channel_groups in client._transport._wrapped_methods + client._transport.get_access_binding in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -75549,29 +75354,29 @@ def test_list_channel_groups_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_channel_groups + client._transport.get_access_binding ] = mock_rpc request = {} - client.list_channel_groups(request) + client.get_access_binding(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_channel_groups(request) + client.get_access_binding(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_channel_groups_rest_required_fields( - request_type=analytics_admin.ListChannelGroupsRequest, +def test_get_access_binding_rest_required_fields( + request_type=analytics_admin.GetAccessBindingRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -75582,28 +75387,21 @@ def test_list_channel_groups_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_channel_groups._get_unset_required_fields(jsonified_request) + ).get_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_channel_groups._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).get_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -75612,7 +75410,7 @@ def test_list_channel_groups_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListChannelGroupsResponse() + return_value = resources.AccessBinding() # 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 @@ -75633,38 +75431,30 @@ def test_list_channel_groups_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListChannelGroupsResponse.pb(return_value) + return_value = resources.AccessBinding.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_channel_groups(request) + response = client.get_access_binding(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_channel_groups_rest_unset_required_fields(): +def test_get_access_binding_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_channel_groups._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.get_access_binding._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_channel_groups_rest_flattened(): +def test_get_access_binding_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -75673,14 +75463,14 @@ def test_list_channel_groups_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 = analytics_admin.ListChannelGroupsResponse() + return_value = resources.AccessBinding() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"name": "accounts/sample1/accessBindings/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) @@ -75688,25 +75478,25 @@ def test_list_channel_groups_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListChannelGroupsResponse.pb(return_value) + return_value = resources.AccessBinding.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_channel_groups(**mock_args) + client.get_access_binding(**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=properties/*}/channelGroups" % client.transport._host, + "%s/v1alpha/{name=accounts/*/accessBindings/*}" % client.transport._host, args[1], ) -def test_list_channel_groups_rest_flattened_error(transport: str = "rest"): +def test_get_access_binding_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -75715,76 +75505,13 @@ def test_list_channel_groups_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_channel_groups( - analytics_admin.ListChannelGroupsRequest(), - parent="parent_value", - ) - - -def test_list_channel_groups_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListChannelGroupsResponse( - channel_groups=[ - channel_group.ChannelGroup(), - channel_group.ChannelGroup(), - channel_group.ChannelGroup(), - ], - next_page_token="abc", - ), - analytics_admin.ListChannelGroupsResponse( - channel_groups=[], - next_page_token="def", - ), - analytics_admin.ListChannelGroupsResponse( - channel_groups=[ - channel_group.ChannelGroup(), - ], - next_page_token="ghi", - ), - analytics_admin.ListChannelGroupsResponse( - channel_groups=[ - channel_group.ChannelGroup(), - channel_group.ChannelGroup(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListChannelGroupsResponse.to_json(x) for x in response + client.get_access_binding( + analytics_admin.GetAccessBindingRequest(), + name="name_value", ) - 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": "properties/sample1"} - - pager = client.list_channel_groups(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, channel_group.ChannelGroup) for i in results) - - pages = list(client.list_channel_groups(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_create_channel_group_rest_use_cached_wrapped_rpc(): +def test_update_access_binding_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: @@ -75799,7 +75526,8 @@ def test_create_channel_group_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_channel_group in client._transport._wrapped_methods + client._transport.update_access_binding + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -75808,29 +75536,28 @@ def test_create_channel_group_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_channel_group + client._transport.update_access_binding ] = mock_rpc request = {} - client.create_channel_group(request) + client.update_access_binding(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_channel_group(request) + client.update_access_binding(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_channel_group_rest_required_fields( - request_type=analytics_admin.CreateChannelGroupRequest, +def test_update_access_binding_rest_required_fields( + request_type=analytics_admin.UpdateAccessBindingRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -75841,21 +75568,17 @@ def test_create_channel_group_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_channel_group._get_unset_required_fields(jsonified_request) + ).update_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_channel_group._get_unset_required_fields(jsonified_request) + ).update_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -75864,7 +75587,7 @@ def test_create_channel_group_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_channel_group.ChannelGroup() + return_value = resources.AccessBinding() # 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 @@ -75876,7 +75599,7 @@ def test_create_channel_group_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -75886,38 +75609,30 @@ def test_create_channel_group_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_channel_group.ChannelGroup.pb(return_value) + return_value = resources.AccessBinding.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.create_channel_group(request) + response = client.update_access_binding(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_channel_group_rest_unset_required_fields(): +def test_update_access_binding_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_channel_group._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "channelGroup", - ) - ) - ) + unset_fields = transport.update_access_binding._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("accessBinding",))) -def test_create_channel_group_rest_flattened(): +def test_update_access_binding_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -75926,15 +75641,16 @@ def test_create_channel_group_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 = gaa_channel_group.ChannelGroup() + return_value = resources.AccessBinding() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "access_binding": {"name": "accounts/sample1/accessBindings/sample2"} + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - channel_group=gaa_channel_group.ChannelGroup(name="name_value"), + access_binding=resources.AccessBinding(user="user_value"), ) mock_args.update(sample_request) @@ -75942,25 +75658,26 @@ def test_create_channel_group_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_channel_group.ChannelGroup.pb(return_value) + return_value = resources.AccessBinding.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_channel_group(**mock_args) + client.update_access_binding(**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=properties/*}/channelGroups" % client.transport._host, + "%s/v1alpha/{access_binding.name=accounts/*/accessBindings/*}" + % client.transport._host, args[1], ) -def test_create_channel_group_rest_flattened_error(transport: str = "rest"): +def test_update_access_binding_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -75969,14 +75686,13 @@ def test_create_channel_group_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_channel_group( - analytics_admin.CreateChannelGroupRequest(), - parent="parent_value", - channel_group=gaa_channel_group.ChannelGroup(name="name_value"), + client.update_access_binding( + analytics_admin.UpdateAccessBindingRequest(), + access_binding=resources.AccessBinding(user="user_value"), ) -def test_update_channel_group_rest_use_cached_wrapped_rpc(): +def test_delete_access_binding_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: @@ -75991,7 +75707,8 @@ def test_update_channel_group_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_channel_group in client._transport._wrapped_methods + client._transport.delete_access_binding + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -76000,28 +75717,29 @@ def test_update_channel_group_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_channel_group + client._transport.delete_access_binding ] = mock_rpc request = {} - client.update_channel_group(request) + client.delete_access_binding(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_channel_group(request) + client.delete_access_binding(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_channel_group_rest_required_fields( - request_type=analytics_admin.UpdateChannelGroupRequest, +def test_delete_access_binding_rest_required_fields( + request_type=analytics_admin.DeleteAccessBindingRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -76032,19 +75750,21 @@ def test_update_channel_group_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_channel_group._get_unset_required_fields(jsonified_request) + ).delete_access_binding._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_channel_group._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",)) + ).delete_access_binding._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -76053,7 +75773,7 @@ def test_update_channel_group_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_channel_group.ChannelGroup() + 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 @@ -76065,48 +75785,36 @@ def test_update_channel_group_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = gaa_channel_group.ChannelGroup.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"} - response = client.update_channel_group(request) + response = client.delete_access_binding(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_channel_group_rest_unset_required_fields(): +def test_delete_access_binding_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_channel_group._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "channelGroup", - "updateMask", - ) - ) - ) + unset_fields = transport.delete_access_binding._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_channel_group_rest_flattened(): +def test_delete_access_binding_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -76115,44 +75823,38 @@ def test_update_channel_group_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 = gaa_channel_group.ChannelGroup() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "channel_group": {"name": "properties/sample1/channelGroups/sample2"} - } + sample_request = {"name": "accounts/sample1/accessBindings/sample2"} # get truthy value for each flattened field mock_args = dict( - channel_group=gaa_channel_group.ChannelGroup(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_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 = gaa_channel_group.ChannelGroup.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.update_channel_group(**mock_args) + client.delete_access_binding(**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/{channel_group.name=properties/*/channelGroups/*}" - % client.transport._host, + "%s/v1alpha/{name=accounts/*/accessBindings/*}" % client.transport._host, args[1], ) -def test_update_channel_group_rest_flattened_error(transport: str = "rest"): +def test_delete_access_binding_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -76161,14 +75863,13 @@ def test_update_channel_group_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_channel_group( - analytics_admin.UpdateChannelGroupRequest(), - channel_group=gaa_channel_group.ChannelGroup(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.delete_access_binding( + analytics_admin.DeleteAccessBindingRequest(), + name="name_value", ) -def test_delete_channel_group_rest_use_cached_wrapped_rpc(): +def test_list_access_bindings_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: @@ -76183,7 +75884,7 @@ def test_delete_channel_group_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_channel_group in client._transport._wrapped_methods + client._transport.list_access_bindings in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -76192,29 +75893,29 @@ def test_delete_channel_group_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_channel_group + client._transport.list_access_bindings ] = mock_rpc request = {} - client.delete_channel_group(request) + client.list_access_bindings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_channel_group(request) + client.list_access_bindings(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_channel_group_rest_required_fields( - request_type=analytics_admin.DeleteChannelGroupRequest, +def test_list_access_bindings_rest_required_fields( + request_type=analytics_admin.ListAccessBindingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -76225,21 +75926,28 @@ def test_delete_channel_group_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_channel_group._get_unset_required_fields(jsonified_request) + ).list_access_bindings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_channel_group._get_unset_required_fields(jsonified_request) + ).list_access_bindings._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -76248,7 +75956,7 @@ def test_delete_channel_group_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.ListAccessBindingsResponse() # 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 @@ -76260,76 +75968,89 @@ def test_delete_channel_group_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = analytics_admin.ListAccessBindingsResponse.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_channel_group(request) + response = client.list_access_bindings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_channel_group_rest_unset_required_fields(): +def test_list_access_bindings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_channel_group._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_delete_channel_group_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - + unset_fields = transport.list_access_bindings._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_access_bindings_rest_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.ListAccessBindingsResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/channelGroups/sample2"} + sample_request = {"parent": "accounts/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_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 = analytics_admin.ListAccessBindingsResponse.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_channel_group(**mock_args) + client.list_access_bindings(**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=properties/*/channelGroups/*}" % client.transport._host, + "%s/v1alpha/{parent=accounts/*}/accessBindings" % client.transport._host, args[1], ) -def test_delete_channel_group_rest_flattened_error(transport: str = "rest"): +def test_list_access_bindings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -76338,13 +76059,76 @@ def test_delete_channel_group_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_channel_group( - analytics_admin.DeleteChannelGroupRequest(), - name="name_value", + client.list_access_bindings( + analytics_admin.ListAccessBindingsRequest(), + parent="parent_value", ) -def test_set_automated_ga4_configuration_opt_out_rest_use_cached_wrapped_rpc(): +def test_list_access_bindings_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListAccessBindingsResponse( + access_bindings=[ + resources.AccessBinding(), + resources.AccessBinding(), + resources.AccessBinding(), + ], + next_page_token="abc", + ), + analytics_admin.ListAccessBindingsResponse( + access_bindings=[], + next_page_token="def", + ), + analytics_admin.ListAccessBindingsResponse( + access_bindings=[ + resources.AccessBinding(), + ], + next_page_token="ghi", + ), + analytics_admin.ListAccessBindingsResponse( + access_bindings=[ + resources.AccessBinding(), + resources.AccessBinding(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListAccessBindingsResponse.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": "accounts/sample1"} + + pager = client.list_access_bindings(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.AccessBinding) for i in results) + + pages = list(client.list_access_bindings(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_batch_create_access_bindings_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: @@ -76359,7 +76143,7 @@ def test_set_automated_ga4_configuration_opt_out_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.set_automated_ga4_configuration_opt_out + client._transport.batch_create_access_bindings in client._transport._wrapped_methods ) @@ -76369,29 +76153,29 @@ def test_set_automated_ga4_configuration_opt_out_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.set_automated_ga4_configuration_opt_out + client._transport.batch_create_access_bindings ] = mock_rpc request = {} - client.set_automated_ga4_configuration_opt_out(request) + client.batch_create_access_bindings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.set_automated_ga4_configuration_opt_out(request) + client.batch_create_access_bindings(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_automated_ga4_configuration_opt_out_rest_required_fields( - request_type=analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, +def test_batch_create_access_bindings_rest_required_fields( + request_type=analytics_admin.BatchCreateAccessBindingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["property"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -76402,25 +76186,21 @@ def test_set_automated_ga4_configuration_opt_out_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).set_automated_ga4_configuration_opt_out._get_unset_required_fields( - jsonified_request - ) + ).batch_create_access_bindings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["property"] = "property_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).set_automated_ga4_configuration_opt_out._get_unset_required_fields( - jsonified_request - ) + ).batch_create_access_bindings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "property" in jsonified_request - assert jsonified_request["property"] == "property_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -76429,7 +76209,7 @@ def test_set_automated_ga4_configuration_opt_out_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + return_value = analytics_admin.BatchCreateAccessBindingsResponse() # 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 @@ -76451,10 +76231,8 @@ def test_set_automated_ga4_configuration_opt_out_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = ( - analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.pb( - return_value - ) + return_value = analytics_admin.BatchCreateAccessBindingsResponse.pb( + return_value ) json_return_value = json_format.MessageToJson(return_value) @@ -76462,25 +76240,31 @@ def test_set_automated_ga4_configuration_opt_out_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.set_automated_ga4_configuration_opt_out(request) + response = client.batch_create_access_bindings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_set_automated_ga4_configuration_opt_out_rest_unset_required_fields(): +def test_batch_create_access_bindings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.set_automated_ga4_configuration_opt_out._get_unset_required_fields({}) + unset_fields = transport.batch_create_access_bindings._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "requests", + ) + ) ) - assert set(unset_fields) == (set(()) & set(("property",))) -def test_fetch_automated_ga4_configuration_opt_out_rest_use_cached_wrapped_rpc(): +def test_batch_get_access_bindings_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: @@ -76495,7 +76279,7 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_use_cached_wrapped_rpc() # Ensure method has been cached assert ( - client._transport.fetch_automated_ga4_configuration_opt_out + client._transport.batch_get_access_bindings in client._transport._wrapped_methods ) @@ -76505,29 +76289,30 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_use_cached_wrapped_rpc() "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.fetch_automated_ga4_configuration_opt_out + client._transport.batch_get_access_bindings ] = mock_rpc request = {} - client.fetch_automated_ga4_configuration_opt_out(request) + client.batch_get_access_bindings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.fetch_automated_ga4_configuration_opt_out(request) + client.batch_get_access_bindings(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_automated_ga4_configuration_opt_out_rest_required_fields( - request_type=analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest, +def test_batch_get_access_bindings_rest_required_fields( + request_type=analytics_admin.BatchGetAccessBindingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["property"] = "" + request_init["parent"] = "" + request_init["names"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -76535,28 +76320,32 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_required_fields( ) # verify fields with default values are dropped + assert "names" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).fetch_automated_ga4_configuration_opt_out._get_unset_required_fields( - jsonified_request - ) + ).batch_get_access_bindings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "names" in jsonified_request + assert jsonified_request["names"] == request_init["names"] - jsonified_request["property"] = "property_value" + jsonified_request["parent"] = "parent_value" + jsonified_request["names"] = "names_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).fetch_automated_ga4_configuration_opt_out._get_unset_required_fields( - jsonified_request - ) + ).batch_get_access_bindings._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("names",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "property" in jsonified_request - assert jsonified_request["property"] == "property_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "names" in jsonified_request + assert jsonified_request["names"] == "names_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -76565,7 +76354,7 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() + return_value = analytics_admin.BatchGetAccessBindingsResponse() # 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 @@ -76577,20 +76366,17 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = ( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse.pb( - return_value - ) + return_value = analytics_admin.BatchGetAccessBindingsResponse.pb( + return_value ) json_return_value = json_format.MessageToJson(return_value) @@ -76598,27 +76384,37 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.fetch_automated_ga4_configuration_opt_out(request) + response = client.batch_get_access_bindings(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "names", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_fetch_automated_ga4_configuration_opt_out_rest_unset_required_fields(): +def test_batch_get_access_bindings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.fetch_automated_ga4_configuration_opt_out._get_unset_required_fields( - {} + unset_fields = transport.batch_get_access_bindings._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("names",)) + & set( + ( + "parent", + "names", + ) ) ) - assert set(unset_fields) == (set(()) & set(("property",))) -def test_create_big_query_link_rest_use_cached_wrapped_rpc(): +def test_batch_update_access_bindings_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: @@ -76633,7 +76429,7 @@ def test_create_big_query_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_big_query_link + client._transport.batch_update_access_bindings in client._transport._wrapped_methods ) @@ -76643,24 +76439,24 @@ def test_create_big_query_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_big_query_link + client._transport.batch_update_access_bindings ] = mock_rpc request = {} - client.create_big_query_link(request) + client.batch_update_access_bindings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_big_query_link(request) + client.batch_update_access_bindings(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_big_query_link_rest_required_fields( - request_type=analytics_admin.CreateBigQueryLinkRequest, +def test_batch_update_access_bindings_rest_required_fields( + request_type=analytics_admin.BatchUpdateAccessBindingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -76676,7 +76472,7 @@ def test_create_big_query_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_big_query_link._get_unset_required_fields(jsonified_request) + ).batch_update_access_bindings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -76685,7 +76481,7 @@ def test_create_big_query_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_big_query_link._get_unset_required_fields(jsonified_request) + ).batch_update_access_bindings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -76699,7 +76495,7 @@ def test_create_big_query_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.BigQueryLink() + return_value = analytics_admin.BatchUpdateAccessBindingsResponse() # 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 @@ -76721,97 +76517,171 @@ def test_create_big_query_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.BigQueryLink.pb(return_value) + return_value = analytics_admin.BatchUpdateAccessBindingsResponse.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.create_big_query_link(request) + response = client.batch_update_access_bindings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_big_query_link_rest_unset_required_fields(): +def test_batch_update_access_bindings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_big_query_link._get_unset_required_fields({}) + unset_fields = transport.batch_update_access_bindings._get_unset_required_fields({}) assert set(unset_fields) == ( set(()) & set( ( "parent", - "bigqueryLink", + "requests", ) ) ) -def test_create_big_query_link_rest_flattened(): +def test_batch_delete_access_bindings_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 = AnalyticsAdminServiceClient( + 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.batch_delete_access_bindings + 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.batch_delete_access_bindings + ] = mock_rpc + + request = {} + client.batch_delete_access_bindings(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.batch_delete_access_bindings(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_batch_delete_access_bindings_rest_required_fields( + request_type=analytics_admin.BatchDeleteAccessBindingsRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport + + 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() + ).batch_delete_access_bindings._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() + ).batch_delete_access_bindings._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + client = AnalyticsAdminServiceClient( 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(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = resources.BigQueryLink() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + 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 - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - bigquery_link=resources.BigQueryLink(name="name_value"), - ) - mock_args.update(sample_request) + response_value = Response() + response_value.status_code = 200 + json_return_value = "" - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = resources.BigQueryLink.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_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_big_query_link(**mock_args) + response = client.batch_delete_access_bindings(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/v1alpha/{parent=properties/*}/bigQueryLinks" % client.transport._host, - args[1], - ) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -def test_create_big_query_link_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, +def test_batch_delete_access_bindings_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + 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_big_query_link( - analytics_admin.CreateBigQueryLinkRequest(), - parent="parent_value", - bigquery_link=resources.BigQueryLink(name="name_value"), + unset_fields = transport.batch_delete_access_bindings._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "requests", + ) ) + ) -def test_get_big_query_link_rest_use_cached_wrapped_rpc(): +def test_get_expanded_data_set_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: @@ -76826,7 +76696,8 @@ def test_get_big_query_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_big_query_link in client._transport._wrapped_methods + client._transport.get_expanded_data_set + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -76835,24 +76706,24 @@ def test_get_big_query_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_big_query_link + client._transport.get_expanded_data_set ] = mock_rpc request = {} - client.get_big_query_link(request) + client.get_expanded_data_set(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_big_query_link(request) + client.get_expanded_data_set(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_big_query_link_rest_required_fields( - request_type=analytics_admin.GetBigQueryLinkRequest, +def test_get_expanded_data_set_rest_required_fields( + request_type=analytics_admin.GetExpandedDataSetRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -76868,7 +76739,7 @@ def test_get_big_query_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_big_query_link._get_unset_required_fields(jsonified_request) + ).get_expanded_data_set._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -76877,7 +76748,7 @@ def test_get_big_query_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_big_query_link._get_unset_required_fields(jsonified_request) + ).get_expanded_data_set._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -76891,7 +76762,7 @@ def test_get_big_query_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.BigQueryLink() + return_value = expanded_data_set.ExpandedDataSet() # 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 @@ -76912,30 +76783,30 @@ def test_get_big_query_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.BigQueryLink.pb(return_value) + return_value = expanded_data_set.ExpandedDataSet.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_big_query_link(request) + response = client.get_expanded_data_set(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_big_query_link_rest_unset_required_fields(): +def test_get_expanded_data_set_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_big_query_link._get_unset_required_fields({}) + unset_fields = transport.get_expanded_data_set._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_big_query_link_rest_flattened(): +def test_get_expanded_data_set_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -76944,10 +76815,10 @@ def test_get_big_query_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.BigQueryLink() + return_value = expanded_data_set.ExpandedDataSet() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/bigQueryLinks/sample2"} + sample_request = {"name": "properties/sample1/expandedDataSets/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -76959,25 +76830,26 @@ def test_get_big_query_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.BigQueryLink.pb(return_value) + return_value = expanded_data_set.ExpandedDataSet.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_big_query_link(**mock_args) + client.get_expanded_data_set(**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=properties/*/bigQueryLinks/*}" % client.transport._host, + "%s/v1alpha/{name=properties/*/expandedDataSets/*}" + % client.transport._host, args[1], ) -def test_get_big_query_link_rest_flattened_error(transport: str = "rest"): +def test_get_expanded_data_set_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -76986,13 +76858,13 @@ def test_get_big_query_link_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_big_query_link( - analytics_admin.GetBigQueryLinkRequest(), + client.get_expanded_data_set( + analytics_admin.GetExpandedDataSetRequest(), name="name_value", ) -def test_list_big_query_links_rest_use_cached_wrapped_rpc(): +def test_list_expanded_data_sets_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: @@ -77007,7 +76879,8 @@ def test_list_big_query_links_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_big_query_links in client._transport._wrapped_methods + client._transport.list_expanded_data_sets + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -77016,24 +76889,24 @@ def test_list_big_query_links_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_big_query_links + client._transport.list_expanded_data_sets ] = mock_rpc request = {} - client.list_big_query_links(request) + client.list_expanded_data_sets(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_big_query_links(request) + client.list_expanded_data_sets(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_big_query_links_rest_required_fields( - request_type=analytics_admin.ListBigQueryLinksRequest, +def test_list_expanded_data_sets_rest_required_fields( + request_type=analytics_admin.ListExpandedDataSetsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -77049,7 +76922,7 @@ def test_list_big_query_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_big_query_links._get_unset_required_fields(jsonified_request) + ).list_expanded_data_sets._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -77058,7 +76931,7 @@ def test_list_big_query_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_big_query_links._get_unset_required_fields(jsonified_request) + ).list_expanded_data_sets._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( @@ -77079,7 +76952,7 @@ def test_list_big_query_links_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListBigQueryLinksResponse() + return_value = analytics_admin.ListExpandedDataSetsResponse() # 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 @@ -77100,26 +76973,26 @@ def test_list_big_query_links_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListBigQueryLinksResponse.pb(return_value) + return_value = analytics_admin.ListExpandedDataSetsResponse.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_big_query_links(request) + response = client.list_expanded_data_sets(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_big_query_links_rest_unset_required_fields(): +def test_list_expanded_data_sets_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_big_query_links._get_unset_required_fields({}) + unset_fields = transport.list_expanded_data_sets._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( @@ -77131,7 +77004,7 @@ def test_list_big_query_links_rest_unset_required_fields(): ) -def test_list_big_query_links_rest_flattened(): +def test_list_expanded_data_sets_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -77140,7 +77013,7 @@ def test_list_big_query_links_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 = analytics_admin.ListBigQueryLinksResponse() + return_value = analytics_admin.ListExpandedDataSetsResponse() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -77155,25 +77028,26 @@ def test_list_big_query_links_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListBigQueryLinksResponse.pb(return_value) + return_value = analytics_admin.ListExpandedDataSetsResponse.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_big_query_links(**mock_args) + client.list_expanded_data_sets(**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=properties/*}/bigQueryLinks" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/expandedDataSets" + % client.transport._host, args[1], ) -def test_list_big_query_links_rest_flattened_error(transport: str = "rest"): +def test_list_expanded_data_sets_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -77182,13 +77056,13 @@ def test_list_big_query_links_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_big_query_links( - analytics_admin.ListBigQueryLinksRequest(), - parent="parent_value", + client.list_expanded_data_sets( + analytics_admin.ListExpandedDataSetsRequest(), + parent="parent_value", ) -def test_list_big_query_links_rest_pager(transport: str = "rest"): +def test_list_expanded_data_sets_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -77200,28 +77074,28 @@ def test_list_big_query_links_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListBigQueryLinksResponse( - bigquery_links=[ - resources.BigQueryLink(), - resources.BigQueryLink(), - resources.BigQueryLink(), + analytics_admin.ListExpandedDataSetsResponse( + expanded_data_sets=[ + expanded_data_set.ExpandedDataSet(), + expanded_data_set.ExpandedDataSet(), + expanded_data_set.ExpandedDataSet(), ], next_page_token="abc", ), - analytics_admin.ListBigQueryLinksResponse( - bigquery_links=[], + analytics_admin.ListExpandedDataSetsResponse( + expanded_data_sets=[], next_page_token="def", ), - analytics_admin.ListBigQueryLinksResponse( - bigquery_links=[ - resources.BigQueryLink(), + analytics_admin.ListExpandedDataSetsResponse( + expanded_data_sets=[ + expanded_data_set.ExpandedDataSet(), ], next_page_token="ghi", ), - analytics_admin.ListBigQueryLinksResponse( - bigquery_links=[ - resources.BigQueryLink(), - resources.BigQueryLink(), + analytics_admin.ListExpandedDataSetsResponse( + expanded_data_sets=[ + expanded_data_set.ExpandedDataSet(), + expanded_data_set.ExpandedDataSet(), ], ), ) @@ -77230,7 +77104,7 @@ def test_list_big_query_links_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListBigQueryLinksResponse.to_json(x) for x in response + analytics_admin.ListExpandedDataSetsResponse.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): @@ -77240,18 +77114,18 @@ def test_list_big_query_links_rest_pager(transport: str = "rest"): sample_request = {"parent": "properties/sample1"} - pager = client.list_big_query_links(request=sample_request) + pager = client.list_expanded_data_sets(request=sample_request) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, resources.BigQueryLink) for i in results) + assert all(isinstance(i, expanded_data_set.ExpandedDataSet) for i in results) - pages = list(client.list_big_query_links(request=sample_request).pages) + pages = list(client.list_expanded_data_sets(request=sample_request).pages) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_delete_big_query_link_rest_use_cached_wrapped_rpc(): +def test_create_expanded_data_set_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: @@ -77266,7 +77140,7 @@ def test_delete_big_query_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_big_query_link + client._transport.create_expanded_data_set in client._transport._wrapped_methods ) @@ -77276,29 +77150,29 @@ def test_delete_big_query_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_big_query_link + client._transport.create_expanded_data_set ] = mock_rpc request = {} - client.delete_big_query_link(request) + client.create_expanded_data_set(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_big_query_link(request) + client.create_expanded_data_set(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_big_query_link_rest_required_fields( - request_type=analytics_admin.DeleteBigQueryLinkRequest, +def test_create_expanded_data_set_rest_required_fields( + request_type=analytics_admin.CreateExpandedDataSetRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -77309,21 +77183,21 @@ def test_delete_big_query_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_big_query_link._get_unset_required_fields(jsonified_request) + ).create_expanded_data_set._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_big_query_link._get_unset_required_fields(jsonified_request) + ).create_expanded_data_set._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -77332,7 +77206,7 @@ def test_delete_big_query_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = gaa_expanded_data_set.ExpandedDataSet() # 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 @@ -77344,36 +77218,48 @@ def test_delete_big_query_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 = gaa_expanded_data_set.ExpandedDataSet.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_big_query_link(request) + response = client.create_expanded_data_set(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_big_query_link_rest_unset_required_fields(): +def test_create_expanded_data_set_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_big_query_link._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_expanded_data_set._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "expandedDataSet", + ) + ) + ) -def test_delete_big_query_link_rest_flattened(): +def test_create_expanded_data_set_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -77382,38 +77268,42 @@ def test_delete_big_query_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 = gaa_expanded_data_set.ExpandedDataSet() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/bigQueryLinks/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(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 = "" + # Convert return value to protobuf type + return_value = gaa_expanded_data_set.ExpandedDataSet.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_big_query_link(**mock_args) + client.create_expanded_data_set(**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=properties/*/bigQueryLinks/*}" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/expandedDataSets" + % client.transport._host, args[1], ) -def test_delete_big_query_link_rest_flattened_error(transport: str = "rest"): +def test_create_expanded_data_set_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -77422,13 +77312,14 @@ def test_delete_big_query_link_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_big_query_link( - analytics_admin.DeleteBigQueryLinkRequest(), - name="name_value", + client.create_expanded_data_set( + analytics_admin.CreateExpandedDataSetRequest(), + parent="parent_value", + expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), ) -def test_update_big_query_link_rest_use_cached_wrapped_rpc(): +def test_update_expanded_data_set_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: @@ -77443,7 +77334,7 @@ def test_update_big_query_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_big_query_link + client._transport.update_expanded_data_set in client._transport._wrapped_methods ) @@ -77453,24 +77344,24 @@ def test_update_big_query_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_big_query_link + client._transport.update_expanded_data_set ] = mock_rpc request = {} - client.update_big_query_link(request) + client.update_expanded_data_set(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_big_query_link(request) + client.update_expanded_data_set(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_big_query_link_rest_required_fields( - request_type=analytics_admin.UpdateBigQueryLinkRequest, +def test_update_expanded_data_set_rest_required_fields( + request_type=analytics_admin.UpdateExpandedDataSetRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -77485,14 +77376,14 @@ def test_update_big_query_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_big_query_link._get_unset_required_fields(jsonified_request) + ).update_expanded_data_set._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_big_query_link._get_unset_required_fields(jsonified_request) + ).update_expanded_data_set._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) @@ -77506,7 +77397,7 @@ def test_update_big_query_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.BigQueryLink() + return_value = gaa_expanded_data_set.ExpandedDataSet() # 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 @@ -77528,38 +77419,38 @@ def test_update_big_query_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.BigQueryLink.pb(return_value) + return_value = gaa_expanded_data_set.ExpandedDataSet.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_big_query_link(request) + response = client.update_expanded_data_set(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_big_query_link_rest_unset_required_fields(): +def test_update_expanded_data_set_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_big_query_link._get_unset_required_fields({}) + unset_fields = transport.update_expanded_data_set._get_unset_required_fields({}) assert set(unset_fields) == ( set(("updateMask",)) & set( ( - "bigqueryLink", + "expandedDataSet", "updateMask", ) ) ) -def test_update_big_query_link_rest_flattened(): +def test_update_expanded_data_set_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -77568,16 +77459,16 @@ def test_update_big_query_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.BigQueryLink() + return_value = gaa_expanded_data_set.ExpandedDataSet() # get arguments that satisfy an http rule for this method sample_request = { - "bigquery_link": {"name": "properties/sample1/bigQueryLinks/sample2"} + "expanded_data_set": {"name": "properties/sample1/expandedDataSets/sample2"} } # get truthy value for each flattened field mock_args = dict( - bigquery_link=resources.BigQueryLink(name="name_value"), + expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -77586,26 +77477,26 @@ def test_update_big_query_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.BigQueryLink.pb(return_value) + return_value = gaa_expanded_data_set.ExpandedDataSet.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.update_big_query_link(**mock_args) + client.update_expanded_data_set(**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/{bigquery_link.name=properties/*/bigQueryLinks/*}" + "%s/v1alpha/{expanded_data_set.name=properties/*/expandedDataSets/*}" % client.transport._host, args[1], ) -def test_update_big_query_link_rest_flattened_error(transport: str = "rest"): +def test_update_expanded_data_set_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -77614,14 +77505,14 @@ def test_update_big_query_link_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_big_query_link( - analytics_admin.UpdateBigQueryLinkRequest(), - bigquery_link=resources.BigQueryLink(name="name_value"), + client.update_expanded_data_set( + analytics_admin.UpdateExpandedDataSetRequest(), + expanded_data_set=gaa_expanded_data_set.ExpandedDataSet(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_enhanced_measurement_settings_rest_use_cached_wrapped_rpc(): +def test_delete_expanded_data_set_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: @@ -77636,7 +77527,7 @@ def test_get_enhanced_measurement_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_enhanced_measurement_settings + client._transport.delete_expanded_data_set in client._transport._wrapped_methods ) @@ -77646,24 +77537,24 @@ def test_get_enhanced_measurement_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_enhanced_measurement_settings + client._transport.delete_expanded_data_set ] = mock_rpc request = {} - client.get_enhanced_measurement_settings(request) + client.delete_expanded_data_set(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_enhanced_measurement_settings(request) + client.delete_expanded_data_set(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_enhanced_measurement_settings_rest_required_fields( - request_type=analytics_admin.GetEnhancedMeasurementSettingsRequest, +def test_delete_expanded_data_set_rest_required_fields( + request_type=analytics_admin.DeleteExpandedDataSetRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -77679,7 +77570,7 @@ def test_get_enhanced_measurement_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_enhanced_measurement_settings._get_unset_required_fields(jsonified_request) + ).delete_expanded_data_set._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -77688,7 +77579,7 @@ def test_get_enhanced_measurement_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_enhanced_measurement_settings._get_unset_required_fields(jsonified_request) + ).delete_expanded_data_set._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -77702,7 +77593,7 @@ def test_get_enhanced_measurement_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.EnhancedMeasurementSettings() + 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 @@ -77714,41 +77605,36 @@ def test_get_enhanced_measurement_settings_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "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.EnhancedMeasurementSettings.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"} - response = client.get_enhanced_measurement_settings(request) + response = client.delete_expanded_data_set(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_enhanced_measurement_settings_rest_unset_required_fields(): +def test_delete_expanded_data_set_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.get_enhanced_measurement_settings._get_unset_required_fields({}) - ) + unset_fields = transport.delete_expanded_data_set._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_enhanced_measurement_settings_rest_flattened(): +def test_delete_expanded_data_set_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -77757,12 +77643,10 @@ def test_get_enhanced_measurement_settings_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.EnhancedMeasurementSettings() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" - } + sample_request = {"name": "properties/sample1/expandedDataSets/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -77773,29 +77657,25 @@ def test_get_enhanced_measurement_settings_rest_flattened(): # 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.EnhancedMeasurementSettings.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.get_enhanced_measurement_settings(**mock_args) + client.delete_expanded_data_set(**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=properties/*/dataStreams/*/enhancedMeasurementSettings}" + "%s/v1alpha/{name=properties/*/expandedDataSets/*}" % client.transport._host, args[1], ) -def test_get_enhanced_measurement_settings_rest_flattened_error( - transport: str = "rest", -): +def test_delete_expanded_data_set_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -77804,13 +77684,13 @@ def test_get_enhanced_measurement_settings_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_enhanced_measurement_settings( - analytics_admin.GetEnhancedMeasurementSettingsRequest(), + client.delete_expanded_data_set( + analytics_admin.DeleteExpandedDataSetRequest(), name="name_value", ) -def test_update_enhanced_measurement_settings_rest_use_cached_wrapped_rpc(): +def test_get_channel_group_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: @@ -77824,10 +77704,7 @@ def test_update_enhanced_measurement_settings_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_enhanced_measurement_settings - in client._transport._wrapped_methods - ) + assert client._transport.get_channel_group in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -77835,28 +77712,29 @@ def test_update_enhanced_measurement_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_enhanced_measurement_settings + client._transport.get_channel_group ] = mock_rpc request = {} - client.update_enhanced_measurement_settings(request) + client.get_channel_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_enhanced_measurement_settings(request) + client.get_channel_group(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_enhanced_measurement_settings_rest_required_fields( - request_type=analytics_admin.UpdateEnhancedMeasurementSettingsRequest, +def test_get_channel_group_rest_required_fields( + request_type=analytics_admin.GetChannelGroupRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -77867,19 +77745,21 @@ def test_update_enhanced_measurement_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_enhanced_measurement_settings._get_unset_required_fields(jsonified_request) + ).get_channel_group._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_enhanced_measurement_settings._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).get_channel_group._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -77888,7 +77768,7 @@ def test_update_enhanced_measurement_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.EnhancedMeasurementSettings() + return_value = channel_group.ChannelGroup() # 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 @@ -77900,50 +77780,39 @@ def test_update_enhanced_measurement_settings_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 = resources.EnhancedMeasurementSettings.pb(return_value) + return_value = channel_group.ChannelGroup.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_enhanced_measurement_settings(request) + response = client.get_channel_group(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_enhanced_measurement_settings_rest_unset_required_fields(): +def test_get_channel_group_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.update_enhanced_measurement_settings._get_unset_required_fields({}) - ) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "enhancedMeasurementSettings", - "updateMask", - ) - ) - ) + unset_fields = transport.get_channel_group._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_enhanced_measurement_settings_rest_flattened(): +def test_get_channel_group_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -77952,21 +77821,14 @@ def test_update_enhanced_measurement_settings_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.EnhancedMeasurementSettings() + return_value = channel_group.ChannelGroup() # get arguments that satisfy an http rule for this method - sample_request = { - "enhanced_measurement_settings": { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" - } - } + sample_request = {"name": "properties/sample1/channelGroups/sample2"} # get truthy value for each flattened field mock_args = dict( - enhanced_measurement_settings=resources.EnhancedMeasurementSettings( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) @@ -77974,28 +77836,25 @@ def test_update_enhanced_measurement_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.EnhancedMeasurementSettings.pb(return_value) + return_value = channel_group.ChannelGroup.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.update_enhanced_measurement_settings(**mock_args) + client.get_channel_group(**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/{enhanced_measurement_settings.name=properties/*/dataStreams/*/enhancedMeasurementSettings}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/channelGroups/*}" % client.transport._host, args[1], ) -def test_update_enhanced_measurement_settings_rest_flattened_error( - transport: str = "rest", -): +def test_get_channel_group_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -78004,16 +77863,13 @@ def test_update_enhanced_measurement_settings_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_enhanced_measurement_settings( - analytics_admin.UpdateEnhancedMeasurementSettingsRequest(), - enhanced_measurement_settings=resources.EnhancedMeasurementSettings( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_channel_group( + analytics_admin.GetChannelGroupRequest(), + name="name_value", ) -def test_create_connected_site_tag_rest_use_cached_wrapped_rpc(): +def test_list_channel_groups_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: @@ -78028,8 +77884,7 @@ def test_create_connected_site_tag_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_connected_site_tag - in client._transport._wrapped_methods + client._transport.list_channel_groups in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -78038,28 +77893,29 @@ def test_create_connected_site_tag_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_connected_site_tag + client._transport.list_channel_groups ] = mock_rpc request = {} - client.create_connected_site_tag(request) + client.list_channel_groups(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_connected_site_tag(request) + client.list_channel_groups(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_connected_site_tag_rest_required_fields( - request_type=analytics_admin.CreateConnectedSiteTagRequest, +def test_list_channel_groups_rest_required_fields( + request_type=analytics_admin.ListChannelGroupsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -78070,17 +77926,28 @@ def test_create_connected_site_tag_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_connected_site_tag._get_unset_required_fields(jsonified_request) + ).list_channel_groups._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_connected_site_tag._get_unset_required_fields(jsonified_request) + ).list_channel_groups._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -78089,7 +77956,7 @@ def test_create_connected_site_tag_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.CreateConnectedSiteTagResponse() + return_value = analytics_admin.ListChannelGroupsResponse() # 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 @@ -78101,42 +77968,167 @@ def test_create_connected_site_tag_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.CreateConnectedSiteTagResponse.pb( - return_value - ) + return_value = analytics_admin.ListChannelGroupsResponse.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.create_connected_site_tag(request) + response = client.list_channel_groups(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_connected_site_tag_rest_unset_required_fields(): +def test_list_channel_groups_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_connected_site_tag._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("connectedSiteTag",))) + unset_fields = transport.list_channel_groups._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_delete_connected_site_tag_rest_use_cached_wrapped_rpc(): +def test_list_channel_groups_rest_flattened(): + client = AnalyticsAdminServiceClient( + 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 = analytics_admin.ListChannelGroupsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = analytics_admin.ListChannelGroupsResponse.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_channel_groups(**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=properties/*}/channelGroups" % client.transport._host, + args[1], + ) + + +def test_list_channel_groups_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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_channel_groups( + analytics_admin.ListChannelGroupsRequest(), + parent="parent_value", + ) + + +def test_list_channel_groups_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListChannelGroupsResponse( + channel_groups=[ + channel_group.ChannelGroup(), + channel_group.ChannelGroup(), + channel_group.ChannelGroup(), + ], + next_page_token="abc", + ), + analytics_admin.ListChannelGroupsResponse( + channel_groups=[], + next_page_token="def", + ), + analytics_admin.ListChannelGroupsResponse( + channel_groups=[ + channel_group.ChannelGroup(), + ], + next_page_token="ghi", + ), + analytics_admin.ListChannelGroupsResponse( + channel_groups=[ + channel_group.ChannelGroup(), + channel_group.ChannelGroup(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListChannelGroupsResponse.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": "properties/sample1"} + + pager = client.list_channel_groups(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, channel_group.ChannelGroup) for i in results) + + pages = list(client.list_channel_groups(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_channel_group_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: @@ -78151,8 +78143,7 @@ def test_delete_connected_site_tag_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_connected_site_tag - in client._transport._wrapped_methods + client._transport.create_channel_group in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -78161,111 +78152,29 @@ def test_delete_connected_site_tag_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_connected_site_tag + client._transport.create_channel_group ] = mock_rpc request = {} - client.delete_connected_site_tag(request) + client.create_channel_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_connected_site_tag(request) + client.create_channel_group(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_connected_site_tags_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 = AnalyticsAdminServiceClient( - 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_connected_site_tags - 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_connected_site_tags - ] = mock_rpc - - request = {} - client.list_connected_site_tags(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.list_connected_site_tags(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_connected_ga4_property_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 = AnalyticsAdminServiceClient( - 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_connected_ga4_property - 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_connected_ga4_property - ] = mock_rpc - - request = {} - client.fetch_connected_ga4_property(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.fetch_connected_ga4_property(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_connected_ga4_property_rest_required_fields( - request_type=analytics_admin.FetchConnectedGa4PropertyRequest, +def test_create_channel_group_rest_required_fields( + request_type=analytics_admin.CreateChannelGroupRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["property"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -78273,29 +78182,24 @@ def test_fetch_connected_ga4_property_rest_required_fields( ) # verify fields with default values are dropped - assert "property" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).fetch_connected_ga4_property._get_unset_required_fields(jsonified_request) + ).create_channel_group._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "property" in jsonified_request - assert jsonified_request["property"] == request_init["property"] - jsonified_request["property"] = "property_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).fetch_connected_ga4_property._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("property",)) + ).create_channel_group._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "property" in jsonified_request - assert jsonified_request["property"] == "property_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -78304,7 +78208,7 @@ def test_fetch_connected_ga4_property_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.FetchConnectedGa4PropertyResponse() + return_value = gaa_channel_group.ChannelGroup() # 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 @@ -78316,47 +78220,107 @@ def test_fetch_connected_ga4_property_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 = analytics_admin.FetchConnectedGa4PropertyResponse.pb( - return_value - ) + return_value = gaa_channel_group.ChannelGroup.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_connected_ga4_property(request) + response = client.create_channel_group(request) - expected_params = [ - ( - "property", - "", - ), - ("$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_fetch_connected_ga4_property_rest_unset_required_fields(): +def test_create_channel_group_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.fetch_connected_ga4_property._get_unset_required_fields({}) - assert set(unset_fields) == (set(("property",)) & set(("property",))) + unset_fields = transport.create_channel_group._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "channelGroup", + ) + ) + ) -def test_get_ad_sense_link_rest_use_cached_wrapped_rpc(): +def test_create_channel_group_rest_flattened(): + client = AnalyticsAdminServiceClient( + 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 = gaa_channel_group.ChannelGroup() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + channel_group=gaa_channel_group.ChannelGroup(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 = gaa_channel_group.ChannelGroup.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_channel_group(**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=properties/*}/channelGroups" % client.transport._host, + args[1], + ) + + +def test_create_channel_group_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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_channel_group( + analytics_admin.CreateChannelGroupRequest(), + parent="parent_value", + channel_group=gaa_channel_group.ChannelGroup(name="name_value"), + ) + + +def test_update_channel_group_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: @@ -78370,7 +78334,9 @@ def test_get_ad_sense_link_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_ad_sense_link in client._transport._wrapped_methods + assert ( + client._transport.update_channel_group in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -78378,29 +78344,28 @@ def test_get_ad_sense_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_ad_sense_link + client._transport.update_channel_group ] = mock_rpc request = {} - client.get_ad_sense_link(request) + client.update_channel_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_ad_sense_link(request) + client.update_channel_group(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_ad_sense_link_rest_required_fields( - request_type=analytics_admin.GetAdSenseLinkRequest, +def test_update_channel_group_rest_required_fields( + request_type=analytics_admin.UpdateChannelGroupRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -78411,21 +78376,19 @@ def test_get_ad_sense_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_ad_sense_link._get_unset_required_fields(jsonified_request) + ).update_channel_group._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_ad_sense_link._get_unset_required_fields(jsonified_request) + ).update_channel_group._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -78434,7 +78397,7 @@ def test_get_ad_sense_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AdSenseLink() + return_value = gaa_channel_group.ChannelGroup() # 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 @@ -78446,39 +78409,48 @@ def test_get_ad_sense_link_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 = resources.AdSenseLink.pb(return_value) + return_value = gaa_channel_group.ChannelGroup.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_ad_sense_link(request) + response = client.update_channel_group(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_ad_sense_link_rest_unset_required_fields(): +def test_update_channel_group_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_ad_sense_link._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.update_channel_group._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "channelGroup", + "updateMask", + ) + ) + ) -def test_get_ad_sense_link_rest_flattened(): +def test_update_channel_group_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -78487,14 +78459,17 @@ def test_get_ad_sense_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.AdSenseLink() + return_value = gaa_channel_group.ChannelGroup() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/adSenseLinks/sample2"} + sample_request = { + "channel_group": {"name": "properties/sample1/channelGroups/sample2"} + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + channel_group=gaa_channel_group.ChannelGroup(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -78502,25 +78477,26 @@ def test_get_ad_sense_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AdSenseLink.pb(return_value) + return_value = gaa_channel_group.ChannelGroup.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_ad_sense_link(**mock_args) + client.update_channel_group(**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=properties/*/adSenseLinks/*}" % client.transport._host, + "%s/v1alpha/{channel_group.name=properties/*/channelGroups/*}" + % client.transport._host, args[1], ) -def test_get_ad_sense_link_rest_flattened_error(transport: str = "rest"): +def test_update_channel_group_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -78529,13 +78505,14 @@ def test_get_ad_sense_link_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_ad_sense_link( - analytics_admin.GetAdSenseLinkRequest(), - name="name_value", + client.update_channel_group( + analytics_admin.UpdateChannelGroupRequest(), + channel_group=gaa_channel_group.ChannelGroup(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_create_ad_sense_link_rest_use_cached_wrapped_rpc(): +def test_delete_channel_group_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: @@ -78550,7 +78527,7 @@ def test_create_ad_sense_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_ad_sense_link in client._transport._wrapped_methods + client._transport.delete_channel_group in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -78559,29 +78536,29 @@ def test_create_ad_sense_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_ad_sense_link + client._transport.delete_channel_group ] = mock_rpc request = {} - client.create_ad_sense_link(request) + client.delete_channel_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_ad_sense_link(request) + client.delete_channel_group(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_ad_sense_link_rest_required_fields( - request_type=analytics_admin.CreateAdSenseLinkRequest, +def test_delete_channel_group_rest_required_fields( + request_type=analytics_admin.DeleteChannelGroupRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -78592,21 +78569,21 @@ def test_create_ad_sense_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_ad_sense_link._get_unset_required_fields(jsonified_request) + ).delete_channel_group._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_ad_sense_link._get_unset_required_fields(jsonified_request) + ).delete_channel_group._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -78615,7 +78592,7 @@ def test_create_ad_sense_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.AdSenseLink() + 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 @@ -78627,48 +78604,36 @@ def test_create_ad_sense_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = resources.AdSenseLink.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"} - response = client.create_ad_sense_link(request) + response = client.delete_channel_group(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_ad_sense_link_rest_unset_required_fields(): +def test_delete_channel_group_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_ad_sense_link._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "adsenseLink", - ) - ) - ) + unset_fields = transport.delete_channel_group._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_ad_sense_link_rest_flattened(): +def test_delete_channel_group_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -78677,41 +78642,38 @@ def test_create_ad_sense_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.AdSenseLink() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"name": "properties/sample1/channelGroups/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - adsense_link=resources.AdSenseLink(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.AdSenseLink.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_ad_sense_link(**mock_args) + client.delete_channel_group(**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=properties/*}/adSenseLinks" % client.transport._host, + "%s/v1alpha/{name=properties/*/channelGroups/*}" % client.transport._host, args[1], ) -def test_create_ad_sense_link_rest_flattened_error(transport: str = "rest"): +def test_delete_channel_group_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -78720,14 +78682,13 @@ def test_create_ad_sense_link_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_ad_sense_link( - analytics_admin.CreateAdSenseLinkRequest(), - parent="parent_value", - adsense_link=resources.AdSenseLink(name="name_value"), + client.delete_channel_group( + analytics_admin.DeleteChannelGroupRequest(), + name="name_value", ) -def test_delete_ad_sense_link_rest_use_cached_wrapped_rpc(): +def test_set_automated_ga4_configuration_opt_out_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: @@ -78742,7 +78703,8 @@ def test_delete_ad_sense_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_ad_sense_link in client._transport._wrapped_methods + client._transport.set_automated_ga4_configuration_opt_out + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -78751,29 +78713,29 @@ def test_delete_ad_sense_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_ad_sense_link + client._transport.set_automated_ga4_configuration_opt_out ] = mock_rpc request = {} - client.delete_ad_sense_link(request) + client.set_automated_ga4_configuration_opt_out(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_ad_sense_link(request) + client.set_automated_ga4_configuration_opt_out(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_ad_sense_link_rest_required_fields( - request_type=analytics_admin.DeleteAdSenseLinkRequest, +def test_set_automated_ga4_configuration_opt_out_rest_required_fields( + request_type=analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["property"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -78784,21 +78746,25 @@ def test_delete_ad_sense_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_ad_sense_link._get_unset_required_fields(jsonified_request) + ).set_automated_ga4_configuration_opt_out._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["property"] = "property_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_ad_sense_link._get_unset_required_fields(jsonified_request) + ).set_automated_ga4_configuration_opt_out._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 "property" in jsonified_request + assert jsonified_request["property"] == "property_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -78807,7 +78773,7 @@ def test_delete_ad_sense_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() # 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 @@ -78819,91 +78785,46 @@ def test_delete_ad_sense_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 = ( + analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.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_ad_sense_link(request) + response = client.set_automated_ga4_configuration_opt_out(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_ad_sense_link_rest_unset_required_fields(): +def test_set_automated_ga4_configuration_opt_out_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_ad_sense_link._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_delete_ad_sense_link_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/adSenseLinks/sample2"} - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = "" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - - client.delete_ad_sense_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/{name=properties/*/adSenseLinks/*}" % client.transport._host, - args[1], - ) - - -def test_delete_ad_sense_link_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + unset_fields = ( + transport.set_automated_ga4_configuration_opt_out._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.delete_ad_sense_link( - analytics_admin.DeleteAdSenseLinkRequest(), - name="name_value", - ) + assert set(unset_fields) == (set(()) & set(("property",))) -def test_list_ad_sense_links_rest_use_cached_wrapped_rpc(): +def test_fetch_automated_ga4_configuration_opt_out_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: @@ -78918,7 +78839,8 @@ def test_list_ad_sense_links_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_ad_sense_links in client._transport._wrapped_methods + client._transport.fetch_automated_ga4_configuration_opt_out + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -78927,29 +78849,29 @@ def test_list_ad_sense_links_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_ad_sense_links + client._transport.fetch_automated_ga4_configuration_opt_out ] = mock_rpc request = {} - client.list_ad_sense_links(request) + client.fetch_automated_ga4_configuration_opt_out(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_ad_sense_links(request) + client.fetch_automated_ga4_configuration_opt_out(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_ad_sense_links_rest_required_fields( - request_type=analytics_admin.ListAdSenseLinksRequest, +def test_fetch_automated_ga4_configuration_opt_out_rest_required_fields( + request_type=analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["property"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -78960,28 +78882,25 @@ def test_list_ad_sense_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_ad_sense_links._get_unset_required_fields(jsonified_request) + ).fetch_automated_ga4_configuration_opt_out._get_unset_required_fields( + jsonified_request + ) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["property"] = "property_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_ad_sense_links._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) + ).fetch_automated_ga4_configuration_opt_out._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 "property" in jsonified_request + assert jsonified_request["property"] == "property_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -78990,7 +78909,7 @@ def test_list_ad_sense_links_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListAdSenseLinksResponse() + return_value = analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() # 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 @@ -79002,47 +78921,182 @@ def test_list_ad_sense_links_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 = analytics_admin.ListAdSenseLinksResponse.pb(return_value) + return_value = ( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse.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_ad_sense_links(request) + response = client.fetch_automated_ga4_configuration_opt_out(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_ad_sense_links_rest_unset_required_fields(): +def test_fetch_automated_ga4_configuration_opt_out_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_ad_sense_links._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) + unset_fields = ( + transport.fetch_automated_ga4_configuration_opt_out._get_unset_required_fields( + {} + ) ) + assert set(unset_fields) == (set(()) & set(("property",))) -def test_list_ad_sense_links_rest_flattened(): +def test_create_big_query_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 = AnalyticsAdminServiceClient( + 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_big_query_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.create_big_query_link + ] = mock_rpc + + request = {} + client.create_big_query_link(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.create_big_query_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_create_big_query_link_rest_required_fields( + request_type=analytics_admin.CreateBigQueryLinkRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_big_query_link._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_big_query_link._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = resources.BigQueryLink() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = resources.BigQueryLink.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.create_big_query_link(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_big_query_link_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_big_query_link._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "bigqueryLink", + ) + ) + ) + + +def test_create_big_query_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -79051,7 +79105,7 @@ def test_list_ad_sense_links_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 = analytics_admin.ListAdSenseLinksResponse() + return_value = resources.BigQueryLink() # get arguments that satisfy an http rule for this method sample_request = {"parent": "properties/sample1"} @@ -79059,6 +79113,7 @@ def test_list_ad_sense_links_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", + bigquery_link=resources.BigQueryLink(name="name_value"), ) mock_args.update(sample_request) @@ -79066,25 +79121,25 @@ def test_list_ad_sense_links_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAdSenseLinksResponse.pb(return_value) + return_value = resources.BigQueryLink.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_ad_sense_links(**mock_args) + client.create_big_query_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=properties/*}/adSenseLinks" % client.transport._host, + "%s/v1alpha/{parent=properties/*}/bigQueryLinks" % client.transport._host, args[1], ) -def test_list_ad_sense_links_rest_flattened_error(transport: str = "rest"): +def test_create_big_query_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -79093,76 +79148,14 @@ def test_list_ad_sense_links_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_ad_sense_links( - analytics_admin.ListAdSenseLinksRequest(), + client.create_big_query_link( + analytics_admin.CreateBigQueryLinkRequest(), parent="parent_value", + bigquery_link=resources.BigQueryLink(name="name_value"), ) -def test_list_ad_sense_links_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListAdSenseLinksResponse( - adsense_links=[ - resources.AdSenseLink(), - resources.AdSenseLink(), - resources.AdSenseLink(), - ], - next_page_token="abc", - ), - analytics_admin.ListAdSenseLinksResponse( - adsense_links=[], - next_page_token="def", - ), - analytics_admin.ListAdSenseLinksResponse( - adsense_links=[ - resources.AdSenseLink(), - ], - next_page_token="ghi", - ), - analytics_admin.ListAdSenseLinksResponse( - adsense_links=[ - resources.AdSenseLink(), - resources.AdSenseLink(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListAdSenseLinksResponse.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": "properties/sample1"} - - pager = client.list_ad_sense_links(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.AdSenseLink) for i in results) - - pages = list(client.list_ad_sense_links(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_get_event_create_rule_rest_use_cached_wrapped_rpc(): +def test_get_big_query_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: @@ -79177,8 +79170,7 @@ def test_get_event_create_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_event_create_rule - in client._transport._wrapped_methods + client._transport.get_big_query_link in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -79187,24 +79179,24 @@ def test_get_event_create_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_event_create_rule + client._transport.get_big_query_link ] = mock_rpc request = {} - client.get_event_create_rule(request) + client.get_big_query_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_event_create_rule(request) + client.get_big_query_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_get_event_create_rule_rest_required_fields( - request_type=analytics_admin.GetEventCreateRuleRequest, +def test_get_big_query_link_rest_required_fields( + request_type=analytics_admin.GetBigQueryLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -79220,7 +79212,7 @@ def test_get_event_create_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_event_create_rule._get_unset_required_fields(jsonified_request) + ).get_big_query_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -79229,7 +79221,7 @@ def test_get_event_create_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_event_create_rule._get_unset_required_fields(jsonified_request) + ).get_big_query_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -79243,7 +79235,7 @@ def test_get_event_create_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = event_create_and_edit.EventCreateRule() + return_value = resources.BigQueryLink() # 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 @@ -79264,30 +79256,30 @@ def test_get_event_create_rule_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.pb(return_value) + return_value = resources.BigQueryLink.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_event_create_rule(request) + response = client.get_big_query_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_event_create_rule_rest_unset_required_fields(): +def test_get_big_query_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_event_create_rule._get_unset_required_fields({}) + unset_fields = transport.get_big_query_link._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_event_create_rule_rest_flattened(): +def test_get_big_query_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -79296,12 +79288,10 @@ def test_get_event_create_rule_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 = event_create_and_edit.EventCreateRule() + return_value = resources.BigQueryLink() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" - } + sample_request = {"name": "properties/sample1/bigQueryLinks/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -79313,26 +79303,25 @@ def test_get_event_create_rule_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.pb(return_value) + return_value = resources.BigQueryLink.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_event_create_rule(**mock_args) + client.get_big_query_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/{name=properties/*/dataStreams/*/eventCreateRules/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/bigQueryLinks/*}" % client.transport._host, args[1], ) -def test_get_event_create_rule_rest_flattened_error(transport: str = "rest"): +def test_get_big_query_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -79341,13 +79330,13 @@ def test_get_event_create_rule_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_event_create_rule( - analytics_admin.GetEventCreateRuleRequest(), + client.get_big_query_link( + analytics_admin.GetBigQueryLinkRequest(), name="name_value", ) -def test_list_event_create_rules_rest_use_cached_wrapped_rpc(): +def test_list_big_query_links_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: @@ -79362,8 +79351,7 @@ def test_list_event_create_rules_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_event_create_rules - in client._transport._wrapped_methods + client._transport.list_big_query_links in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -79372,24 +79360,24 @@ def test_list_event_create_rules_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_event_create_rules + client._transport.list_big_query_links ] = mock_rpc request = {} - client.list_event_create_rules(request) + client.list_big_query_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_event_create_rules(request) + client.list_big_query_links(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_event_create_rules_rest_required_fields( - request_type=analytics_admin.ListEventCreateRulesRequest, +def test_list_big_query_links_rest_required_fields( + request_type=analytics_admin.ListBigQueryLinksRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -79405,7 +79393,7 @@ def test_list_event_create_rules_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_event_create_rules._get_unset_required_fields(jsonified_request) + ).list_big_query_links._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -79414,7 +79402,7 @@ def test_list_event_create_rules_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_event_create_rules._get_unset_required_fields(jsonified_request) + ).list_big_query_links._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set( ( @@ -79435,7 +79423,7 @@ def test_list_event_create_rules_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListEventCreateRulesResponse() + return_value = analytics_admin.ListBigQueryLinksResponse() # 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 @@ -79456,26 +79444,26 @@ def test_list_event_create_rules_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListEventCreateRulesResponse.pb(return_value) + return_value = analytics_admin.ListBigQueryLinksResponse.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_event_create_rules(request) + response = client.list_big_query_links(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_event_create_rules_rest_unset_required_fields(): +def test_list_big_query_links_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_event_create_rules._get_unset_required_fields({}) + unset_fields = transport.list_big_query_links._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( @@ -79487,7 +79475,7 @@ def test_list_event_create_rules_rest_unset_required_fields(): ) -def test_list_event_create_rules_rest_flattened(): +def test_list_big_query_links_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -79496,10 +79484,10 @@ def test_list_event_create_rules_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 = analytics_admin.ListEventCreateRulesResponse() + return_value = analytics_admin.ListBigQueryLinksResponse() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -79511,26 +79499,25 @@ def test_list_event_create_rules_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListEventCreateRulesResponse.pb(return_value) + return_value = analytics_admin.ListBigQueryLinksResponse.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_event_create_rules(**mock_args) + client.list_big_query_links(**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=properties/*/dataStreams/*}/eventCreateRules" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/bigQueryLinks" % client.transport._host, args[1], ) -def test_list_event_create_rules_rest_flattened_error(transport: str = "rest"): +def test_list_big_query_links_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -79539,13 +79526,13 @@ def test_list_event_create_rules_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_event_create_rules( - analytics_admin.ListEventCreateRulesRequest(), + client.list_big_query_links( + analytics_admin.ListBigQueryLinksRequest(), parent="parent_value", ) -def test_list_event_create_rules_rest_pager(transport: str = "rest"): +def test_list_big_query_links_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -79557,28 +79544,28 @@ def test_list_event_create_rules_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - analytics_admin.ListEventCreateRulesResponse( - event_create_rules=[ - event_create_and_edit.EventCreateRule(), - event_create_and_edit.EventCreateRule(), - event_create_and_edit.EventCreateRule(), + analytics_admin.ListBigQueryLinksResponse( + bigquery_links=[ + resources.BigQueryLink(), + resources.BigQueryLink(), + resources.BigQueryLink(), ], next_page_token="abc", ), - analytics_admin.ListEventCreateRulesResponse( - event_create_rules=[], + analytics_admin.ListBigQueryLinksResponse( + bigquery_links=[], next_page_token="def", ), - analytics_admin.ListEventCreateRulesResponse( - event_create_rules=[ - event_create_and_edit.EventCreateRule(), + analytics_admin.ListBigQueryLinksResponse( + bigquery_links=[ + resources.BigQueryLink(), ], next_page_token="ghi", ), - analytics_admin.ListEventCreateRulesResponse( - event_create_rules=[ - event_create_and_edit.EventCreateRule(), - event_create_and_edit.EventCreateRule(), + analytics_admin.ListBigQueryLinksResponse( + bigquery_links=[ + resources.BigQueryLink(), + resources.BigQueryLink(), ], ), ) @@ -79587,7 +79574,7 @@ def test_list_event_create_rules_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - analytics_admin.ListEventCreateRulesResponse.to_json(x) for x in response + analytics_admin.ListBigQueryLinksResponse.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): @@ -79595,22 +79582,20 @@ def test_list_event_create_rules_rest_pager(transport: str = "rest"): return_val.status_code = 200 req.side_effect = return_values - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = {"parent": "properties/sample1"} - pager = client.list_event_create_rules(request=sample_request) + pager = client.list_big_query_links(request=sample_request) results = list(pager) assert len(results) == 6 - assert all( - isinstance(i, event_create_and_edit.EventCreateRule) for i in results - ) + assert all(isinstance(i, resources.BigQueryLink) for i in results) - pages = list(client.list_event_create_rules(request=sample_request).pages) + pages = list(client.list_big_query_links(request=sample_request).pages) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_create_event_create_rule_rest_use_cached_wrapped_rpc(): +def test_delete_big_query_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: @@ -79625,7 +79610,7 @@ def test_create_event_create_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_event_create_rule + client._transport.delete_big_query_link in client._transport._wrapped_methods ) @@ -79635,29 +79620,29 @@ def test_create_event_create_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_event_create_rule + client._transport.delete_big_query_link ] = mock_rpc request = {} - client.create_event_create_rule(request) + client.delete_big_query_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_event_create_rule(request) + client.delete_big_query_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_create_event_create_rule_rest_required_fields( - request_type=analytics_admin.CreateEventCreateRuleRequest, +def test_delete_big_query_link_rest_required_fields( + request_type=analytics_admin.DeleteBigQueryLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -79668,21 +79653,21 @@ def test_create_event_create_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_event_create_rule._get_unset_required_fields(jsonified_request) + ).delete_big_query_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_event_create_rule._get_unset_required_fields(jsonified_request) + ).delete_big_query_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -79691,7 +79676,7 @@ def test_create_event_create_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = event_create_and_edit.EventCreateRule() + 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 @@ -79703,48 +79688,36 @@ def test_create_event_create_rule_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.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"} - response = client.create_event_create_rule(request) + response = client.delete_big_query_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_event_create_rule_rest_unset_required_fields(): +def test_delete_big_query_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_event_create_rule._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "eventCreateRule", - ) - ) - ) + unset_fields = transport.delete_big_query_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_event_create_rule_rest_flattened(): +def test_delete_big_query_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -79753,42 +79726,38 @@ def test_create_event_create_rule_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 = event_create_and_edit.EventCreateRule() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + sample_request = {"name": "properties/sample1/bigQueryLinks/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - event_create_rule=event_create_and_edit.EventCreateRule(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 = event_create_and_edit.EventCreateRule.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_event_create_rule(**mock_args) + client.delete_big_query_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=properties/*/dataStreams/*}/eventCreateRules" - % client.transport._host, + "%s/v1alpha/{name=properties/*/bigQueryLinks/*}" % client.transport._host, args[1], ) -def test_create_event_create_rule_rest_flattened_error(transport: str = "rest"): +def test_delete_big_query_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -79797,14 +79766,13 @@ def test_create_event_create_rule_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_event_create_rule( - analytics_admin.CreateEventCreateRuleRequest(), - parent="parent_value", - event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), + client.delete_big_query_link( + analytics_admin.DeleteBigQueryLinkRequest(), + name="name_value", ) -def test_update_event_create_rule_rest_use_cached_wrapped_rpc(): +def test_update_big_query_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: @@ -79819,7 +79787,7 @@ def test_update_event_create_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_event_create_rule + client._transport.update_big_query_link in client._transport._wrapped_methods ) @@ -79829,24 +79797,24 @@ def test_update_event_create_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_event_create_rule + client._transport.update_big_query_link ] = mock_rpc request = {} - client.update_event_create_rule(request) + client.update_big_query_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_event_create_rule(request) + client.update_big_query_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_update_event_create_rule_rest_required_fields( - request_type=analytics_admin.UpdateEventCreateRuleRequest, +def test_update_big_query_link_rest_required_fields( + request_type=analytics_admin.UpdateBigQueryLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -79861,14 +79829,14 @@ def test_update_event_create_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_event_create_rule._get_unset_required_fields(jsonified_request) + ).update_big_query_link._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_event_create_rule._get_unset_required_fields(jsonified_request) + ).update_big_query_link._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) @@ -79882,7 +79850,7 @@ def test_update_event_create_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = event_create_and_edit.EventCreateRule() + return_value = resources.BigQueryLink() # 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 @@ -79904,38 +79872,38 @@ def test_update_event_create_rule_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.pb(return_value) + return_value = resources.BigQueryLink.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_event_create_rule(request) + response = client.update_big_query_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_event_create_rule_rest_unset_required_fields(): +def test_update_big_query_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_event_create_rule._get_unset_required_fields({}) + unset_fields = transport.update_big_query_link._get_unset_required_fields({}) assert set(unset_fields) == ( set(("updateMask",)) & set( ( - "eventCreateRule", + "bigqueryLink", "updateMask", ) ) ) -def test_update_event_create_rule_rest_flattened(): +def test_update_big_query_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -79944,18 +79912,16 @@ def test_update_event_create_rule_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 = event_create_and_edit.EventCreateRule() + return_value = resources.BigQueryLink() # get arguments that satisfy an http rule for this method sample_request = { - "event_create_rule": { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" - } + "bigquery_link": {"name": "properties/sample1/bigQueryLinks/sample2"} } # get truthy value for each flattened field mock_args = dict( - event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), + bigquery_link=resources.BigQueryLink(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -79964,26 +79930,26 @@ def test_update_event_create_rule_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.pb(return_value) + return_value = resources.BigQueryLink.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.update_event_create_rule(**mock_args) + client.update_big_query_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/{event_create_rule.name=properties/*/dataStreams/*/eventCreateRules/*}" + "%s/v1alpha/{bigquery_link.name=properties/*/bigQueryLinks/*}" % client.transport._host, args[1], ) -def test_update_event_create_rule_rest_flattened_error(transport: str = "rest"): +def test_update_big_query_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -79992,14 +79958,14 @@ def test_update_event_create_rule_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_event_create_rule( - analytics_admin.UpdateEventCreateRuleRequest(), - event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), + client.update_big_query_link( + analytics_admin.UpdateBigQueryLinkRequest(), + bigquery_link=resources.BigQueryLink(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_event_create_rule_rest_use_cached_wrapped_rpc(): +def test_get_enhanced_measurement_settings_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: @@ -80014,7 +79980,7 @@ def test_delete_event_create_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_event_create_rule + client._transport.get_enhanced_measurement_settings in client._transport._wrapped_methods ) @@ -80024,24 +79990,24 @@ def test_delete_event_create_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_event_create_rule + client._transport.get_enhanced_measurement_settings ] = mock_rpc request = {} - client.delete_event_create_rule(request) + client.get_enhanced_measurement_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_event_create_rule(request) + client.get_enhanced_measurement_settings(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_event_create_rule_rest_required_fields( - request_type=analytics_admin.DeleteEventCreateRuleRequest, +def test_get_enhanced_measurement_settings_rest_required_fields( + request_type=analytics_admin.GetEnhancedMeasurementSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -80057,7 +80023,7 @@ def test_delete_event_create_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_event_create_rule._get_unset_required_fields(jsonified_request) + ).get_enhanced_measurement_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -80066,7 +80032,7 @@ def test_delete_event_create_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_event_create_rule._get_unset_required_fields(jsonified_request) + ).get_enhanced_measurement_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -80080,7 +80046,7 @@ def test_delete_event_create_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.EnhancedMeasurementSettings() # 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 @@ -80092,36 +80058,41 @@ def test_delete_event_create_rule_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.EnhancedMeasurementSettings.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_event_create_rule(request) + response = client.get_enhanced_measurement_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_event_create_rule_rest_unset_required_fields(): +def test_get_enhanced_measurement_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_event_create_rule._get_unset_required_fields({}) + unset_fields = ( + transport.get_enhanced_measurement_settings._get_unset_required_fields({}) + ) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_event_create_rule_rest_flattened(): +def test_get_enhanced_measurement_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -80130,11 +80101,11 @@ def test_delete_event_create_rule_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 = resources.EnhancedMeasurementSettings() # get arguments that satisfy an http rule for this method sample_request = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" } # get truthy value for each flattened field @@ -80146,25 +80117,29 @@ def test_delete_event_create_rule_rest_flattened(): # 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 = resources.EnhancedMeasurementSettings.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_event_create_rule(**mock_args) + client.get_enhanced_measurement_settings(**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=properties/*/dataStreams/*/eventCreateRules/*}" + "%s/v1alpha/{name=properties/*/dataStreams/*/enhancedMeasurementSettings}" % client.transport._host, args[1], ) -def test_delete_event_create_rule_rest_flattened_error(transport: str = "rest"): +def test_get_enhanced_measurement_settings_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -80173,13 +80148,13 @@ def test_delete_event_create_rule_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_event_create_rule( - analytics_admin.DeleteEventCreateRuleRequest(), + client.get_enhanced_measurement_settings( + analytics_admin.GetEnhancedMeasurementSettingsRequest(), name="name_value", ) -def test_get_event_edit_rule_rest_use_cached_wrapped_rpc(): +def test_update_enhanced_measurement_settings_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: @@ -80194,7 +80169,8 @@ def test_get_event_edit_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_event_edit_rule in client._transport._wrapped_methods + client._transport.update_enhanced_measurement_settings + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -80203,29 +80179,28 @@ def test_get_event_edit_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_event_edit_rule + client._transport.update_enhanced_measurement_settings ] = mock_rpc request = {} - client.get_event_edit_rule(request) + client.update_enhanced_measurement_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_event_edit_rule(request) + client.update_enhanced_measurement_settings(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_event_edit_rule_rest_required_fields( - request_type=analytics_admin.GetEventEditRuleRequest, +def test_update_enhanced_measurement_settings_rest_required_fields( + request_type=analytics_admin.UpdateEnhancedMeasurementSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -80236,21 +80211,19 @@ def test_get_event_edit_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_event_edit_rule._get_unset_required_fields(jsonified_request) + ).update_enhanced_measurement_settings._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_event_edit_rule._get_unset_required_fields(jsonified_request) + ).update_enhanced_measurement_settings._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -80259,7 +80232,7 @@ def test_get_event_edit_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = event_create_and_edit.EventEditRule() + return_value = resources.EnhancedMeasurementSettings() # 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 @@ -80271,39 +80244,50 @@ def test_get_event_edit_rule_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 = event_create_and_edit.EventEditRule.pb(return_value) + return_value = resources.EnhancedMeasurementSettings.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_event_edit_rule(request) + response = client.update_enhanced_measurement_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_event_edit_rule_rest_unset_required_fields(): +def test_update_enhanced_measurement_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_event_edit_rule._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = ( + transport.update_enhanced_measurement_settings._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "enhancedMeasurementSettings", + "updateMask", + ) + ) + ) -def test_get_event_edit_rule_rest_flattened(): +def test_update_enhanced_measurement_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -80312,16 +80296,21 @@ def test_get_event_edit_rule_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 = event_create_and_edit.EventEditRule() + return_value = resources.EnhancedMeasurementSettings() # get arguments that satisfy an http rule for this method sample_request = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + "enhanced_measurement_settings": { + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" + } } # get truthy value for each flattened field mock_args = dict( - name="name_value", + enhanced_measurement_settings=resources.EnhancedMeasurementSettings( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -80329,26 +80318,28 @@ def test_get_event_edit_rule_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventEditRule.pb(return_value) + return_value = resources.EnhancedMeasurementSettings.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_event_edit_rule(**mock_args) + client.update_enhanced_measurement_settings(**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=properties/*/dataStreams/*/eventEditRules/*}" + "%s/v1alpha/{enhanced_measurement_settings.name=properties/*/dataStreams/*/enhancedMeasurementSettings}" % client.transport._host, args[1], ) -def test_get_event_edit_rule_rest_flattened_error(transport: str = "rest"): +def test_update_enhanced_measurement_settings_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -80357,13 +80348,16 @@ def test_get_event_edit_rule_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_event_edit_rule( - analytics_admin.GetEventEditRuleRequest(), - name="name_value", + client.update_enhanced_measurement_settings( + analytics_admin.UpdateEnhancedMeasurementSettingsRequest(), + enhanced_measurement_settings=resources.EnhancedMeasurementSettings( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_list_event_edit_rules_rest_use_cached_wrapped_rpc(): +def test_create_connected_site_tag_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: @@ -80378,7 +80372,7 @@ def test_list_event_edit_rules_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_event_edit_rules + client._transport.create_connected_site_tag in client._transport._wrapped_methods ) @@ -80388,29 +80382,28 @@ def test_list_event_edit_rules_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_event_edit_rules + client._transport.create_connected_site_tag ] = mock_rpc request = {} - client.list_event_edit_rules(request) + client.create_connected_site_tag(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_event_edit_rules(request) + client.create_connected_site_tag(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_event_edit_rules_rest_required_fields( - request_type=analytics_admin.ListEventEditRulesRequest, +def test_create_connected_site_tag_rest_required_fields( + request_type=analytics_admin.CreateConnectedSiteTagRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -80421,28 +80414,17 @@ def test_list_event_edit_rules_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_event_edit_rules._get_unset_required_fields(jsonified_request) + ).create_connected_site_tag._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_event_edit_rules._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).create_connected_site_tag._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -80451,7 +80433,7 @@ def test_list_event_edit_rules_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListEventEditRulesResponse() + return_value = analytics_admin.CreateConnectedSiteTagResponse() # 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 @@ -80463,168 +80445,124 @@ def test_list_event_edit_rules_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 = analytics_admin.ListEventEditRulesResponse.pb(return_value) + return_value = analytics_admin.CreateConnectedSiteTagResponse.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_event_edit_rules(request) + response = client.create_connected_site_tag(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_event_edit_rules_rest_unset_required_fields(): +def test_create_connected_site_tag_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_event_edit_rules._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.create_connected_site_tag._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("connectedSiteTag",))) -def test_list_event_edit_rules_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_delete_connected_site_tag_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 = AnalyticsAdminServiceClient( + 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 = analytics_admin.ListEventEditRulesResponse() + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + # Ensure method has been cached + assert ( + client._transport.delete_connected_site_tag + in client._transport._wrapped_methods + ) - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", + # 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. ) - mock_args.update(sample_request) + client._transport._wrapped_methods[ + client._transport.delete_connected_site_tag + ] = mock_rpc - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = analytics_admin.ListEventEditRulesResponse.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"} + request = {} + client.delete_connected_site_tag(request) - client.list_event_edit_rules(**mock_args) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # 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=properties/*/dataStreams/*}/eventEditRules" - % client.transport._host, - args[1], - ) + client.delete_connected_site_tag(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_event_edit_rules_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_event_edit_rules( - analytics_admin.ListEventEditRulesRequest(), - parent="parent_value", +def test_list_connected_site_tags_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -def test_list_event_edit_rules_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListEventEditRulesResponse( - event_edit_rules=[ - event_create_and_edit.EventEditRule(), - event_create_and_edit.EventEditRule(), - event_create_and_edit.EventEditRule(), - ], - next_page_token="abc", - ), - analytics_admin.ListEventEditRulesResponse( - event_edit_rules=[], - next_page_token="def", - ), - analytics_admin.ListEventEditRulesResponse( - event_edit_rules=[ - event_create_and_edit.EventEditRule(), - ], - next_page_token="ghi", - ), - analytics_admin.ListEventEditRulesResponse( - event_edit_rules=[ - event_create_and_edit.EventEditRule(), - event_create_and_edit.EventEditRule(), - ], - ), + # Ensure method has been cached + assert ( + client._transport.list_connected_site_tags + in client._transport._wrapped_methods ) - # Two responses for two calls - response = response + response - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListEventEditRulesResponse.to_json(x) for x in response + # 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. ) - 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 + client._transport._wrapped_methods[ + client._transport.list_connected_site_tags + ] = mock_rpc - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} + request = {} + client.list_connected_site_tags(request) - pager = client.list_event_edit_rules(request=sample_request) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, event_create_and_edit.EventEditRule) for i in results) + client.list_connected_site_tags(request) - pages = list(client.list_event_edit_rules(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token + # 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_event_edit_rule_rest_use_cached_wrapped_rpc(): +def test_fetch_connected_ga4_property_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: @@ -80639,7 +80577,7 @@ def test_create_event_edit_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_event_edit_rule + client._transport.fetch_connected_ga4_property in client._transport._wrapped_methods ) @@ -80649,29 +80587,29 @@ def test_create_event_edit_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_event_edit_rule + client._transport.fetch_connected_ga4_property ] = mock_rpc request = {} - client.create_event_edit_rule(request) + client.fetch_connected_ga4_property(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_event_edit_rule(request) + client.fetch_connected_ga4_property(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_event_edit_rule_rest_required_fields( - request_type=analytics_admin.CreateEventEditRuleRequest, +def test_fetch_connected_ga4_property_rest_required_fields( + request_type=analytics_admin.FetchConnectedGa4PropertyRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["property"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -80679,24 +80617,29 @@ def test_create_event_edit_rule_rest_required_fields( ) # verify fields with default values are dropped + assert "property" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_event_edit_rule._get_unset_required_fields(jsonified_request) + ).fetch_connected_ga4_property._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "property" in jsonified_request + assert jsonified_request["property"] == request_init["property"] - jsonified_request["parent"] = "parent_value" + jsonified_request["property"] = "property_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_event_edit_rule._get_unset_required_fields(jsonified_request) + ).fetch_connected_ga4_property._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("property",)) 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 "property" in jsonified_request + assert jsonified_request["property"] == "property_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -80705,7 +80648,7 @@ def test_create_event_edit_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = event_create_and_edit.EventEditRule() + return_value = analytics_admin.FetchConnectedGa4PropertyResponse() # 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 @@ -80717,108 +80660,47 @@ def test_create_event_edit_rule_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventEditRule.pb(return_value) + return_value = analytics_admin.FetchConnectedGa4PropertyResponse.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.create_event_edit_rule(request) + response = client.fetch_connected_ga4_property(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "property", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_event_edit_rule_rest_unset_required_fields(): +def test_fetch_connected_ga4_property_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_event_edit_rule._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "eventEditRule", - ) - ) - ) - - -def test_create_event_edit_rule_rest_flattened(): - client = AnalyticsAdminServiceClient( - 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 = event_create_and_edit.EventEditRule() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1/dataStreams/sample2"} - - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - event_edit_rule=event_create_and_edit.EventEditRule(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 = event_create_and_edit.EventEditRule.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_event_edit_rule(**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=properties/*/dataStreams/*}/eventEditRules" - % client.transport._host, - args[1], - ) - - -def test_create_event_edit_rule_rest_flattened_error(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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_event_edit_rule( - analytics_admin.CreateEventEditRuleRequest(), - parent="parent_value", - event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), - ) + unset_fields = transport.fetch_connected_ga4_property._get_unset_required_fields({}) + assert set(unset_fields) == (set(("property",)) & set(("property",))) -def test_update_event_edit_rule_rest_use_cached_wrapped_rpc(): +def test_get_ad_sense_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: @@ -80832,10 +80714,7 @@ def test_update_event_edit_rule_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_event_edit_rule - in client._transport._wrapped_methods - ) + assert client._transport.get_ad_sense_link in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -80843,28 +80722,29 @@ def test_update_event_edit_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_event_edit_rule + client._transport.get_ad_sense_link ] = mock_rpc request = {} - client.update_event_edit_rule(request) + client.get_ad_sense_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_event_edit_rule(request) + client.get_ad_sense_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_update_event_edit_rule_rest_required_fields( - request_type=analytics_admin.UpdateEventEditRuleRequest, +def test_get_ad_sense_link_rest_required_fields( + request_type=analytics_admin.GetAdSenseLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -80875,19 +80755,21 @@ def test_update_event_edit_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_event_edit_rule._get_unset_required_fields(jsonified_request) + ).get_ad_sense_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() - ).update_event_edit_rule._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).get_ad_sense_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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -80896,7 +80778,7 @@ def test_update_event_edit_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = event_create_and_edit.EventEditRule() + return_value = resources.AdSenseLink() # 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 @@ -80908,48 +80790,39 @@ def test_update_event_edit_rule_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 = event_create_and_edit.EventEditRule.pb(return_value) + return_value = resources.AdSenseLink.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_event_edit_rule(request) + response = client.get_ad_sense_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_event_edit_rule_rest_unset_required_fields(): +def test_get_ad_sense_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_event_edit_rule._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "eventEditRule", - "updateMask", - ) - ) - ) + unset_fields = transport.get_ad_sense_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_event_edit_rule_rest_flattened(): +def test_get_ad_sense_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -80958,19 +80831,14 @@ def test_update_event_edit_rule_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 = event_create_and_edit.EventEditRule() + return_value = resources.AdSenseLink() # get arguments that satisfy an http rule for this method - sample_request = { - "event_edit_rule": { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" - } - } + sample_request = {"name": "properties/sample1/adSenseLinks/sample2"} # get truthy value for each flattened field mock_args = dict( - event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) @@ -80978,26 +80846,25 @@ def test_update_event_edit_rule_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventEditRule.pb(return_value) + return_value = resources.AdSenseLink.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.update_event_edit_rule(**mock_args) + client.get_ad_sense_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/{event_edit_rule.name=properties/*/dataStreams/*/eventEditRules/*}" - % client.transport._host, + "%s/v1alpha/{name=properties/*/adSenseLinks/*}" % client.transport._host, args[1], ) -def test_update_event_edit_rule_rest_flattened_error(transport: str = "rest"): +def test_get_ad_sense_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -81006,14 +80873,13 @@ def test_update_event_edit_rule_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_event_edit_rule( - analytics_admin.UpdateEventEditRuleRequest(), - event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_ad_sense_link( + analytics_admin.GetAdSenseLinkRequest(), + name="name_value", ) -def test_delete_event_edit_rule_rest_use_cached_wrapped_rpc(): +def test_create_ad_sense_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: @@ -81028,8 +80894,7 @@ def test_delete_event_edit_rule_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_event_edit_rule - in client._transport._wrapped_methods + client._transport.create_ad_sense_link in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -81038,29 +80903,29 @@ def test_delete_event_edit_rule_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_event_edit_rule + client._transport.create_ad_sense_link ] = mock_rpc request = {} - client.delete_event_edit_rule(request) + client.create_ad_sense_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_event_edit_rule(request) + client.create_ad_sense_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_event_edit_rule_rest_required_fields( - request_type=analytics_admin.DeleteEventEditRuleRequest, +def test_create_ad_sense_link_rest_required_fields( + request_type=analytics_admin.CreateAdSenseLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -81071,21 +80936,21 @@ def test_delete_event_edit_rule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_event_edit_rule._get_unset_required_fields(jsonified_request) + ).create_ad_sense_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" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_event_edit_rule._get_unset_required_fields(jsonified_request) + ).create_ad_sense_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" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -81094,7 +80959,7 @@ def test_delete_event_edit_rule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.AdSenseLink() # 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 @@ -81106,36 +80971,48 @@ def test_delete_event_edit_rule_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 = resources.AdSenseLink.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_event_edit_rule(request) + response = client.create_ad_sense_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_event_edit_rule_rest_unset_required_fields(): +def test_create_ad_sense_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_event_edit_rule._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_ad_sense_link._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "adsenseLink", + ) + ) + ) -def test_delete_event_edit_rule_rest_flattened(): +def test_create_ad_sense_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -81144,41 +81021,41 @@ def test_delete_event_edit_rule_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 = resources.AdSenseLink() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + adsense_link=resources.AdSenseLink(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 = "" + # Convert return value to protobuf type + return_value = resources.AdSenseLink.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_event_edit_rule(**mock_args) + client.create_ad_sense_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/{name=properties/*/dataStreams/*/eventEditRules/*}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/adSenseLinks" % client.transport._host, args[1], ) -def test_delete_event_edit_rule_rest_flattened_error(transport: str = "rest"): +def test_create_ad_sense_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -81187,13 +81064,14 @@ def test_delete_event_edit_rule_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_event_edit_rule( - analytics_admin.DeleteEventEditRuleRequest(), - name="name_value", + client.create_ad_sense_link( + analytics_admin.CreateAdSenseLinkRequest(), + parent="parent_value", + adsense_link=resources.AdSenseLink(name="name_value"), ) -def test_reorder_event_edit_rules_rest_use_cached_wrapped_rpc(): +def test_delete_ad_sense_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: @@ -81208,8 +81086,7 @@ def test_reorder_event_edit_rules_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.reorder_event_edit_rules - in client._transport._wrapped_methods + client._transport.delete_ad_sense_link in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -81218,30 +81095,29 @@ def test_reorder_event_edit_rules_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.reorder_event_edit_rules + client._transport.delete_ad_sense_link ] = mock_rpc request = {} - client.reorder_event_edit_rules(request) + client.delete_ad_sense_link(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.reorder_event_edit_rules(request) + client.delete_ad_sense_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_reorder_event_edit_rules_rest_required_fields( - request_type=analytics_admin.ReorderEventEditRulesRequest, +def test_delete_ad_sense_link_rest_required_fields( + request_type=analytics_admin.DeleteAdSenseLinkRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" - request_init["event_edit_rules"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -81252,24 +81128,21 @@ def test_reorder_event_edit_rules_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).reorder_event_edit_rules._get_unset_required_fields(jsonified_request) + ).delete_ad_sense_link._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - jsonified_request["eventEditRules"] = "event_edit_rules_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).reorder_event_edit_rules._get_unset_required_fields(jsonified_request) + ).delete_ad_sense_link._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 "eventEditRules" in jsonified_request - assert jsonified_request["eventEditRules"] == "event_edit_rules_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -81290,10 +81163,9 @@ def test_reorder_event_edit_rules_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() @@ -81304,31 +81176,78 @@ def test_reorder_event_edit_rules_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.reorder_event_edit_rules(request) + response = client.delete_ad_sense_link(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_reorder_event_edit_rules_rest_unset_required_fields(): +def test_delete_ad_sense_link_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.reorder_event_edit_rules._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "eventEditRules", - ) + unset_fields = transport.delete_ad_sense_link._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_ad_sense_link_rest_flattened(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/adSenseLinks/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.delete_ad_sense_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/{name=properties/*/adSenseLinks/*}" % client.transport._host, + args[1], ) + + +def test_delete_ad_sense_link_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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_ad_sense_link( + analytics_admin.DeleteAdSenseLinkRequest(), + name="name_value", + ) + -def test_update_data_redaction_settings_rest_use_cached_wrapped_rpc(): +def test_list_ad_sense_links_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: @@ -81343,8 +81262,7 @@ def test_update_data_redaction_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_data_redaction_settings - in client._transport._wrapped_methods + client._transport.list_ad_sense_links in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -81353,28 +81271,29 @@ def test_update_data_redaction_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_data_redaction_settings + client._transport.list_ad_sense_links ] = mock_rpc request = {} - client.update_data_redaction_settings(request) + client.list_ad_sense_links(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_data_redaction_settings(request) + client.list_ad_sense_links(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_data_redaction_settings_rest_required_fields( - request_type=analytics_admin.UpdateDataRedactionSettingsRequest, +def test_list_ad_sense_links_rest_required_fields( + request_type=analytics_admin.ListAdSenseLinksRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -81385,19 +81304,28 @@ def test_update_data_redaction_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_data_redaction_settings._get_unset_required_fields(jsonified_request) + ).list_ad_sense_links._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_data_redaction_settings._get_unset_required_fields(jsonified_request) + ).list_ad_sense_links._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( + ( + "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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -81406,7 +81334,7 @@ def test_update_data_redaction_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataRedactionSettings() + return_value = analytics_admin.ListAdSenseLinksResponse() # 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 @@ -81418,50 +81346,47 @@ def test_update_data_redaction_settings_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 = resources.DataRedactionSettings.pb(return_value) + return_value = analytics_admin.ListAdSenseLinksResponse.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_data_redaction_settings(request) + response = client.list_ad_sense_links(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_data_redaction_settings_rest_unset_required_fields(): +def test_list_ad_sense_links_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_data_redaction_settings._get_unset_required_fields( - {} - ) + unset_fields = transport.list_ad_sense_links._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) - & set( + set( ( - "dataRedactionSettings", - "updateMask", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_update_data_redaction_settings_rest_flattened(): +def test_list_ad_sense_links_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -81470,19 +81395,14 @@ def test_update_data_redaction_settings_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.DataRedactionSettings() + return_value = analytics_admin.ListAdSenseLinksResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "data_redaction_settings": { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" - } - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - data_redaction_settings=resources.DataRedactionSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", ) mock_args.update(sample_request) @@ -81490,26 +81410,25 @@ def test_update_data_redaction_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRedactionSettings.pb(return_value) + return_value = analytics_admin.ListAdSenseLinksResponse.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.update_data_redaction_settings(**mock_args) + client.list_ad_sense_links(**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/{data_redaction_settings.name=properties/*/dataStreams/*/dataRedactionSettings}" - % client.transport._host, + "%s/v1alpha/{parent=properties/*}/adSenseLinks" % client.transport._host, args[1], ) -def test_update_data_redaction_settings_rest_flattened_error(transport: str = "rest"): +def test_list_ad_sense_links_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -81518,14 +81437,76 @@ def test_update_data_redaction_settings_rest_flattened_error(transport: str = "r # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_data_redaction_settings( - analytics_admin.UpdateDataRedactionSettingsRequest(), - data_redaction_settings=resources.DataRedactionSettings(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.list_ad_sense_links( + analytics_admin.ListAdSenseLinksRequest(), + parent="parent_value", ) -def test_get_data_redaction_settings_rest_use_cached_wrapped_rpc(): +def test_list_ad_sense_links_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListAdSenseLinksResponse( + adsense_links=[ + resources.AdSenseLink(), + resources.AdSenseLink(), + resources.AdSenseLink(), + ], + next_page_token="abc", + ), + analytics_admin.ListAdSenseLinksResponse( + adsense_links=[], + next_page_token="def", + ), + analytics_admin.ListAdSenseLinksResponse( + adsense_links=[ + resources.AdSenseLink(), + ], + next_page_token="ghi", + ), + analytics_admin.ListAdSenseLinksResponse( + adsense_links=[ + resources.AdSenseLink(), + resources.AdSenseLink(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListAdSenseLinksResponse.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": "properties/sample1"} + + pager = client.list_ad_sense_links(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.AdSenseLink) for i in results) + + pages = list(client.list_ad_sense_links(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_event_create_rule_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: @@ -81540,7 +81521,7 @@ def test_get_data_redaction_settings_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_data_redaction_settings + client._transport.get_event_create_rule in client._transport._wrapped_methods ) @@ -81550,24 +81531,24 @@ def test_get_data_redaction_settings_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_data_redaction_settings + client._transport.get_event_create_rule ] = mock_rpc request = {} - client.get_data_redaction_settings(request) + client.get_event_create_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_data_redaction_settings(request) + client.get_event_create_rule(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_data_redaction_settings_rest_required_fields( - request_type=analytics_admin.GetDataRedactionSettingsRequest, +def test_get_event_create_rule_rest_required_fields( + request_type=analytics_admin.GetEventCreateRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -81583,7 +81564,7 @@ def test_get_data_redaction_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_redaction_settings._get_unset_required_fields(jsonified_request) + ).get_event_create_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -81592,7 +81573,7 @@ def test_get_data_redaction_settings_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_data_redaction_settings._get_unset_required_fields(jsonified_request) + ).get_event_create_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -81606,7 +81587,7 @@ def test_get_data_redaction_settings_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.DataRedactionSettings() + return_value = event_create_and_edit.EventCreateRule() # 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 @@ -81627,30 +81608,30 @@ def test_get_data_redaction_settings_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRedactionSettings.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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_data_redaction_settings(request) + response = client.get_event_create_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_data_redaction_settings_rest_unset_required_fields(): +def test_get_event_create_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_data_redaction_settings._get_unset_required_fields({}) + unset_fields = transport.get_event_create_rule._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_data_redaction_settings_rest_flattened(): +def test_get_event_create_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -81659,11 +81640,11 @@ def test_get_data_redaction_settings_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.DataRedactionSettings() + return_value = event_create_and_edit.EventCreateRule() # get arguments that satisfy an http rule for this method sample_request = { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" } # get truthy value for each flattened field @@ -81676,26 +81657,26 @@ def test_get_data_redaction_settings_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRedactionSettings.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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_data_redaction_settings(**mock_args) + client.get_event_create_rule(**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=properties/*/dataStreams/*/dataRedactionSettings}" + "%s/v1alpha/{name=properties/*/dataStreams/*/eventCreateRules/*}" % client.transport._host, args[1], ) -def test_get_data_redaction_settings_rest_flattened_error(transport: str = "rest"): +def test_get_event_create_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -81704,13 +81685,13 @@ def test_get_data_redaction_settings_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_data_redaction_settings( - analytics_admin.GetDataRedactionSettingsRequest(), + client.get_event_create_rule( + analytics_admin.GetEventCreateRuleRequest(), name="name_value", ) -def test_get_calculated_metric_rest_use_cached_wrapped_rpc(): +def test_list_event_create_rules_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: @@ -81725,7 +81706,7 @@ def test_get_calculated_metric_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_calculated_metric + client._transport.list_event_create_rules in client._transport._wrapped_methods ) @@ -81735,29 +81716,29 @@ def test_get_calculated_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_calculated_metric + client._transport.list_event_create_rules ] = mock_rpc request = {} - client.get_calculated_metric(request) + client.list_event_create_rules(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_calculated_metric(request) + client.list_event_create_rules(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_calculated_metric_rest_required_fields( - request_type=analytics_admin.GetCalculatedMetricRequest, +def test_list_event_create_rules_rest_required_fields( + request_type=analytics_admin.ListEventCreateRulesRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -81768,21 +81749,28 @@ def test_get_calculated_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_calculated_metric._get_unset_required_fields(jsonified_request) + ).list_event_create_rules._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_calculated_metric._get_unset_required_fields(jsonified_request) + ).list_event_create_rules._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -81791,7 +81779,7 @@ def test_get_calculated_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CalculatedMetric() + return_value = analytics_admin.ListEventCreateRulesResponse() # 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 @@ -81812,30 +81800,38 @@ def test_get_calculated_metric_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CalculatedMetric.pb(return_value) + return_value = analytics_admin.ListEventCreateRulesResponse.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_calculated_metric(request) + response = client.list_event_create_rules(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_calculated_metric_rest_unset_required_fields(): +def test_list_event_create_rules_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_calculated_metric._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.list_event_create_rules._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_get_calculated_metric_rest_flattened(): +def test_list_event_create_rules_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -81844,14 +81840,14 @@ def test_get_calculated_metric_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.CalculatedMetric() + return_value = analytics_admin.ListEventCreateRulesResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/calculatedMetrics/sample2"} + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -81859,26 +81855,26 @@ def test_get_calculated_metric_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CalculatedMetric.pb(return_value) + return_value = analytics_admin.ListEventCreateRulesResponse.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_calculated_metric(**mock_args) + client.list_event_create_rules(**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=properties/*/calculatedMetrics/*}" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/eventCreateRules" % client.transport._host, args[1], ) -def test_get_calculated_metric_rest_flattened_error(transport: str = "rest"): +def test_list_event_create_rules_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -81887,61 +81883,125 @@ def test_get_calculated_metric_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_calculated_metric( - analytics_admin.GetCalculatedMetricRequest(), - name="name_value", - ) - - -def test_create_calculated_metric_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 = AnalyticsAdminServiceClient( - 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_calculated_metric - in client._transport._wrapped_methods + client.list_event_create_rules( + analytics_admin.ListEventCreateRulesRequest(), + parent="parent_value", ) - # 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_calculated_metric - ] = mock_rpc - request = {} - client.create_calculated_metric(request) +def test_list_event_create_rules_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListEventCreateRulesResponse( + event_create_rules=[ + event_create_and_edit.EventCreateRule(), + event_create_and_edit.EventCreateRule(), + event_create_and_edit.EventCreateRule(), + ], + next_page_token="abc", + ), + analytics_admin.ListEventCreateRulesResponse( + event_create_rules=[], + next_page_token="def", + ), + analytics_admin.ListEventCreateRulesResponse( + event_create_rules=[ + event_create_and_edit.EventCreateRule(), + ], + next_page_token="ghi", + ), + analytics_admin.ListEventCreateRulesResponse( + event_create_rules=[ + event_create_and_edit.EventCreateRule(), + event_create_and_edit.EventCreateRule(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListEventCreateRulesResponse.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": "properties/sample1/dataStreams/sample2"} + + pager = client.list_event_create_rules(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, event_create_and_edit.EventCreateRule) for i in results + ) + + pages = list(client.list_event_create_rules(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_event_create_rule_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 = AnalyticsAdminServiceClient( + 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_event_create_rule + 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_event_create_rule + ] = mock_rpc + + request = {} + client.create_event_create_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_calculated_metric(request) + client.create_event_create_rule(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_calculated_metric_rest_required_fields( - request_type=analytics_admin.CreateCalculatedMetricRequest, +def test_create_event_create_rule_rest_required_fields( + request_type=analytics_admin.CreateEventCreateRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} request_init["parent"] = "" - request_init["calculated_metric_id"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -81949,34 +82009,24 @@ def test_create_calculated_metric_rest_required_fields( ) # verify fields with default values are dropped - assert "calculatedMetricId" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_calculated_metric._get_unset_required_fields(jsonified_request) + ).create_event_create_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "calculatedMetricId" in jsonified_request - assert ( - jsonified_request["calculatedMetricId"] == request_init["calculated_metric_id"] - ) jsonified_request["parent"] = "parent_value" - jsonified_request["calculatedMetricId"] = "calculated_metric_id_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_calculated_metric._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("calculated_metric_id",)) + ).create_event_create_rule._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 "calculatedMetricId" in jsonified_request - assert jsonified_request["calculatedMetricId"] == "calculated_metric_id_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -81985,7 +82035,7 @@ def test_create_calculated_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CalculatedMetric() + return_value = event_create_and_edit.EventCreateRule() # 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 @@ -82007,45 +82057,38 @@ def test_create_calculated_metric_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CalculatedMetric.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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.create_calculated_metric(request) + response = client.create_event_create_rule(request) - expected_params = [ - ( - "calculatedMetricId", - "", - ), - ("$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_calculated_metric_rest_unset_required_fields(): +def test_create_event_create_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_calculated_metric._get_unset_required_fields({}) + unset_fields = transport.create_event_create_rule._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("calculatedMetricId",)) + set(()) & set( ( "parent", - "calculatedMetricId", - "calculatedMetric", + "eventCreateRule", ) ) ) -def test_create_calculated_metric_rest_flattened(): +def test_create_event_create_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -82054,16 +82097,15 @@ def test_create_calculated_metric_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.CalculatedMetric() + return_value = event_create_and_edit.EventCreateRule() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( parent="parent_value", - calculated_metric=resources.CalculatedMetric(name="name_value"), - calculated_metric_id="calculated_metric_id_value", + event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), ) mock_args.update(sample_request) @@ -82071,26 +82113,26 @@ def test_create_calculated_metric_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CalculatedMetric.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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_calculated_metric(**mock_args) + client.create_event_create_rule(**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=properties/*}/calculatedMetrics" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/eventCreateRules" % client.transport._host, args[1], ) -def test_create_calculated_metric_rest_flattened_error(transport: str = "rest"): +def test_create_event_create_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -82099,15 +82141,14 @@ def test_create_calculated_metric_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_calculated_metric( - analytics_admin.CreateCalculatedMetricRequest(), + client.create_event_create_rule( + analytics_admin.CreateEventCreateRuleRequest(), parent="parent_value", - calculated_metric=resources.CalculatedMetric(name="name_value"), - calculated_metric_id="calculated_metric_id_value", + event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), ) -def test_list_calculated_metrics_rest_use_cached_wrapped_rpc(): +def test_update_event_create_rule_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: @@ -82122,7 +82163,7 @@ def test_list_calculated_metrics_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_calculated_metrics + client._transport.update_event_create_rule in client._transport._wrapped_methods ) @@ -82132,29 +82173,28 @@ def test_list_calculated_metrics_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_calculated_metrics + client._transport.update_event_create_rule ] = mock_rpc request = {} - client.list_calculated_metrics(request) + client.update_event_create_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_calculated_metrics(request) + client.update_event_create_rule(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_calculated_metrics_rest_required_fields( - request_type=analytics_admin.ListCalculatedMetricsRequest, +def test_update_event_create_rule_rest_required_fields( + request_type=analytics_admin.UpdateEventCreateRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -82165,28 +82205,19 @@ def test_list_calculated_metrics_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_calculated_metrics._get_unset_required_fields(jsonified_request) + ).update_event_create_rule._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_calculated_metrics._get_unset_required_fields(jsonified_request) + ).update_event_create_rule._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + assert not set(unset_fields) - set(("update_mask",)) 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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -82195,7 +82226,7 @@ def test_list_calculated_metrics_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListCalculatedMetricsResponse() + return_value = event_create_and_edit.EventCreateRule() # 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 @@ -82207,49 +82238,48 @@ def test_list_calculated_metrics_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 = analytics_admin.ListCalculatedMetricsResponse.pb( - return_value - ) + return_value = event_create_and_edit.EventCreateRule.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_calculated_metrics(request) + response = client.update_event_create_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_calculated_metrics_rest_unset_required_fields(): +def test_update_event_create_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_calculated_metrics._get_unset_required_fields({}) + unset_fields = transport.update_event_create_rule._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(("updateMask",)) + & set( ( - "pageSize", - "pageToken", + "eventCreateRule", + "updateMask", ) ) - & set(("parent",)) ) -def test_list_calculated_metrics_rest_flattened(): +def test_update_event_create_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -82258,14 +82288,19 @@ def test_list_calculated_metrics_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 = analytics_admin.ListCalculatedMetricsResponse() + return_value = event_create_and_edit.EventCreateRule() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "event_create_rule": { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + } + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -82273,26 +82308,26 @@ def test_list_calculated_metrics_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCalculatedMetricsResponse.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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_calculated_metrics(**mock_args) + client.update_event_create_rule(**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=properties/*}/calculatedMetrics" + "%s/v1alpha/{event_create_rule.name=properties/*/dataStreams/*/eventCreateRules/*}" % client.transport._host, args[1], ) -def test_list_calculated_metrics_rest_flattened_error(transport: str = "rest"): +def test_update_event_create_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -82301,76 +82336,14 @@ def test_list_calculated_metrics_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_calculated_metrics( - analytics_admin.ListCalculatedMetricsRequest(), - parent="parent_value", - ) - - -def test_list_calculated_metrics_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListCalculatedMetricsResponse( - calculated_metrics=[ - resources.CalculatedMetric(), - resources.CalculatedMetric(), - resources.CalculatedMetric(), - ], - next_page_token="abc", - ), - analytics_admin.ListCalculatedMetricsResponse( - calculated_metrics=[], - next_page_token="def", - ), - analytics_admin.ListCalculatedMetricsResponse( - calculated_metrics=[ - resources.CalculatedMetric(), - ], - next_page_token="ghi", - ), - analytics_admin.ListCalculatedMetricsResponse( - calculated_metrics=[ - resources.CalculatedMetric(), - resources.CalculatedMetric(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListCalculatedMetricsResponse.to_json(x) for x in response + client.update_event_create_rule( + analytics_admin.UpdateEventCreateRuleRequest(), + event_create_rule=event_create_and_edit.EventCreateRule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) - 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": "properties/sample1"} - - pager = client.list_calculated_metrics(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.CalculatedMetric) for i in results) - - pages = list(client.list_calculated_metrics(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_update_calculated_metric_rest_use_cached_wrapped_rpc(): +def test_delete_event_create_rule_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: @@ -82385,7 +82358,7 @@ def test_update_calculated_metric_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_calculated_metric + client._transport.delete_event_create_rule in client._transport._wrapped_methods ) @@ -82395,28 +82368,29 @@ def test_update_calculated_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_calculated_metric + client._transport.delete_event_create_rule ] = mock_rpc request = {} - client.update_calculated_metric(request) + client.delete_event_create_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_calculated_metric(request) + client.delete_event_create_rule(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_calculated_metric_rest_required_fields( - request_type=analytics_admin.UpdateCalculatedMetricRequest, +def test_delete_event_create_rule_rest_required_fields( + request_type=analytics_admin.DeleteEventCreateRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -82427,19 +82401,21 @@ def test_update_calculated_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_calculated_metric._get_unset_required_fields(jsonified_request) + ).delete_event_create_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_calculated_metric._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",)) + ).delete_event_create_rule._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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -82448,7 +82424,7 @@ def test_update_calculated_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.CalculatedMetric() + 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 @@ -82460,48 +82436,36 @@ def test_update_calculated_metric_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = resources.CalculatedMetric.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"} - response = client.update_calculated_metric(request) + response = client.delete_event_create_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_calculated_metric_rest_unset_required_fields(): +def test_delete_event_create_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_calculated_metric._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("updateMask",)) - & set( - ( - "calculatedMetric", - "updateMask", - ) - ) - ) + unset_fields = transport.delete_event_create_rule._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_calculated_metric_rest_flattened(): +def test_delete_event_create_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -82510,46 +82474,41 @@ def test_update_calculated_metric_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.CalculatedMetric() + return_value = None # get arguments that satisfy an http rule for this method sample_request = { - "calculated_metric": { - "name": "properties/sample1/calculatedMetrics/sample2" - } + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" } # get truthy value for each flattened field mock_args = dict( - calculated_metric=resources.CalculatedMetric(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_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.CalculatedMetric.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.update_calculated_metric(**mock_args) + client.delete_event_create_rule(**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/{calculated_metric.name=properties/*/calculatedMetrics/*}" + "%s/v1alpha/{name=properties/*/dataStreams/*/eventCreateRules/*}" % client.transport._host, args[1], ) -def test_update_calculated_metric_rest_flattened_error(transport: str = "rest"): +def test_delete_event_create_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -82558,14 +82517,13 @@ def test_update_calculated_metric_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_calculated_metric( - analytics_admin.UpdateCalculatedMetricRequest(), - calculated_metric=resources.CalculatedMetric(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.delete_event_create_rule( + analytics_admin.DeleteEventCreateRuleRequest(), + name="name_value", ) -def test_delete_calculated_metric_rest_use_cached_wrapped_rpc(): +def test_get_event_edit_rule_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: @@ -82580,8 +82538,7 @@ def test_delete_calculated_metric_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_calculated_metric - in client._transport._wrapped_methods + client._transport.get_event_edit_rule in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -82590,24 +82547,24 @@ def test_delete_calculated_metric_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_calculated_metric + client._transport.get_event_edit_rule ] = mock_rpc request = {} - client.delete_calculated_metric(request) + client.get_event_edit_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_calculated_metric(request) + client.get_event_edit_rule(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_calculated_metric_rest_required_fields( - request_type=analytics_admin.DeleteCalculatedMetricRequest, +def test_get_event_edit_rule_rest_required_fields( + request_type=analytics_admin.GetEventEditRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -82623,7 +82580,7 @@ def test_delete_calculated_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_calculated_metric._get_unset_required_fields(jsonified_request) + ).get_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -82632,7 +82589,7 @@ def test_delete_calculated_metric_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_calculated_metric._get_unset_required_fields(jsonified_request) + ).get_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -82646,7 +82603,7 @@ def test_delete_calculated_metric_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = event_create_and_edit.EventEditRule() # 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 @@ -82658,36 +82615,39 @@ def test_delete_calculated_metric_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = event_create_and_edit.EventEditRule.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_calculated_metric(request) + response = client.get_event_edit_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_calculated_metric_rest_unset_required_fields(): +def test_get_event_edit_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_calculated_metric._get_unset_required_fields({}) + unset_fields = transport.get_event_edit_rule._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_calculated_metric_rest_flattened(): +def test_get_event_edit_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -82696,10 +82656,12 @@ def test_delete_calculated_metric_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 = event_create_and_edit.EventEditRule() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/calculatedMetrics/sample2"} + sample_request = { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + } # get truthy value for each flattened field mock_args = dict( @@ -82710,25 +82672,27 @@ def test_delete_calculated_metric_rest_flattened(): # 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 = event_create_and_edit.EventEditRule.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_calculated_metric(**mock_args) + client.get_event_edit_rule(**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=properties/*/calculatedMetrics/*}" + "%s/v1alpha/{name=properties/*/dataStreams/*/eventEditRules/*}" % client.transport._host, args[1], ) -def test_delete_calculated_metric_rest_flattened_error(transport: str = "rest"): +def test_get_event_edit_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -82737,13 +82701,13 @@ def test_delete_calculated_metric_rest_flattened_error(transport: str = "rest"): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_calculated_metric( - analytics_admin.DeleteCalculatedMetricRequest(), + client.get_event_edit_rule( + analytics_admin.GetEventEditRuleRequest(), name="name_value", ) -def test_create_rollup_property_rest_use_cached_wrapped_rpc(): +def test_list_event_edit_rules_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: @@ -82758,7 +82722,7 @@ def test_create_rollup_property_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_rollup_property + client._transport.list_event_edit_rules in client._transport._wrapped_methods ) @@ -82768,28 +82732,29 @@ def test_create_rollup_property_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_rollup_property + client._transport.list_event_edit_rules ] = mock_rpc request = {} - client.create_rollup_property(request) + client.list_event_edit_rules(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_rollup_property(request) + client.list_event_edit_rules(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_rollup_property_rest_required_fields( - request_type=analytics_admin.CreateRollupPropertyRequest, +def test_list_event_edit_rules_rest_required_fields( + request_type=analytics_admin.ListEventEditRulesRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -82800,17 +82765,28 @@ def test_create_rollup_property_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_rollup_property._get_unset_required_fields(jsonified_request) + ).list_event_edit_rules._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_rollup_property._get_unset_required_fields(jsonified_request) + ).list_event_edit_rules._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -82819,7 +82795,7 @@ def test_create_rollup_property_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.CreateRollupPropertyResponse() + return_value = analytics_admin.ListEventEditRulesResponse() # 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 @@ -82831,185 +82807,63 @@ def test_create_rollup_property_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.CreateRollupPropertyResponse.pb(return_value) + return_value = analytics_admin.ListEventEditRulesResponse.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.create_rollup_property(request) + response = client.list_event_edit_rules(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_rollup_property_rest_unset_required_fields(): +def test_list_event_edit_rules_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_rollup_property._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("rollupProperty",))) - - -def test_get_rollup_property_source_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + unset_fields = transport.list_event_edit_rules._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) ) + & set(("parent",)) + ) - # 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_rollup_property_source_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.get_rollup_property_source_link - ] = mock_rpc - - request = {} - client.get_rollup_property_source_link(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.get_rollup_property_source_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_get_rollup_property_source_link_rest_required_fields( - request_type=analytics_admin.GetRollupPropertySourceLinkRequest, -): - transport_class = transports.AnalyticsAdminServiceRestTransport - - 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_rollup_property_source_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() - ).get_rollup_property_source_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 = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = resources.RollupPropertySourceLink() - # 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.RollupPropertySourceLink.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_rollup_property_source_link(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_get_rollup_property_source_link_rest_unset_required_fields(): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.get_rollup_property_source_link._get_unset_required_fields( - {} - ) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_get_rollup_property_source_link_rest_flattened(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_list_event_edit_rules_rest_flattened(): + client = AnalyticsAdminServiceClient( + 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.RollupPropertySourceLink() + return_value = analytics_admin.ListEventEditRulesResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "properties/sample1/rollupPropertySourceLinks/sample2" - } + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -83017,26 +82871,26 @@ def test_get_rollup_property_source_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.RollupPropertySourceLink.pb(return_value) + return_value = analytics_admin.ListEventEditRulesResponse.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_rollup_property_source_link(**mock_args) + client.list_event_edit_rules(**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=properties/*/rollupPropertySourceLinks/*}" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/eventEditRules" % client.transport._host, args[1], ) -def test_get_rollup_property_source_link_rest_flattened_error(transport: str = "rest"): +def test_list_event_edit_rules_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -83045,13 +82899,76 @@ def test_get_rollup_property_source_link_rest_flattened_error(transport: str = " # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_rollup_property_source_link( - analytics_admin.GetRollupPropertySourceLinkRequest(), - name="name_value", + client.list_event_edit_rules( + analytics_admin.ListEventEditRulesRequest(), + parent="parent_value", ) -def test_list_rollup_property_source_links_rest_use_cached_wrapped_rpc(): +def test_list_event_edit_rules_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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 = ( + analytics_admin.ListEventEditRulesResponse( + event_edit_rules=[ + event_create_and_edit.EventEditRule(), + event_create_and_edit.EventEditRule(), + event_create_and_edit.EventEditRule(), + ], + next_page_token="abc", + ), + analytics_admin.ListEventEditRulesResponse( + event_edit_rules=[], + next_page_token="def", + ), + analytics_admin.ListEventEditRulesResponse( + event_edit_rules=[ + event_create_and_edit.EventEditRule(), + ], + next_page_token="ghi", + ), + analytics_admin.ListEventEditRulesResponse( + event_edit_rules=[ + event_create_and_edit.EventEditRule(), + event_create_and_edit.EventEditRule(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListEventEditRulesResponse.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": "properties/sample1/dataStreams/sample2"} + + pager = client.list_event_edit_rules(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, event_create_and_edit.EventEditRule) for i in results) + + pages = list(client.list_event_edit_rules(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_event_edit_rule_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: @@ -83066,7 +82983,7 @@ def test_list_rollup_property_source_links_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_rollup_property_source_links + client._transport.create_event_edit_rule in client._transport._wrapped_methods ) @@ -83076,24 +82993,24 @@ def test_list_rollup_property_source_links_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_rollup_property_source_links + client._transport.create_event_edit_rule ] = mock_rpc request = {} - client.list_rollup_property_source_links(request) + client.create_event_edit_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_rollup_property_source_links(request) + client.create_event_edit_rule(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_rollup_property_source_links_rest_required_fields( - request_type=analytics_admin.ListRollupPropertySourceLinksRequest, +def test_create_event_edit_rule_rest_required_fields( + request_type=analytics_admin.CreateEventEditRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -83109,7 +83026,7 @@ def test_list_rollup_property_source_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_rollup_property_source_links._get_unset_required_fields(jsonified_request) + ).create_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -83118,14 +83035,7 @@ def test_list_rollup_property_source_links_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_rollup_property_source_links._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).create_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -83139,7 +83049,7 @@ def test_list_rollup_property_source_links_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListRollupPropertySourceLinksResponse() + return_value = event_create_and_edit.EventEditRule() # 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 @@ -83151,51 +83061,48 @@ def test_list_rollup_property_source_links_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 = analytics_admin.ListRollupPropertySourceLinksResponse.pb( - return_value - ) + return_value = event_create_and_edit.EventEditRule.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_rollup_property_source_links(request) + response = client.create_event_edit_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_rollup_property_source_links_rest_unset_required_fields(): +def test_create_event_edit_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.list_rollup_property_source_links._get_unset_required_fields({}) - ) + unset_fields = transport.create_event_edit_rule._get_unset_required_fields({}) assert set(unset_fields) == ( - set( + set(()) + & set( ( - "pageSize", - "pageToken", + "parent", + "eventEditRule", ) ) - & set(("parent",)) ) -def test_list_rollup_property_source_links_rest_flattened(): +def test_create_event_edit_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -83204,14 +83111,15 @@ def test_list_rollup_property_source_links_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 = analytics_admin.ListRollupPropertySourceLinksResponse() + return_value = event_create_and_edit.EventEditRule() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"parent": "properties/sample1/dataStreams/sample2"} # get truthy value for each flattened field mock_args = dict( parent="parent_value", + event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), ) mock_args.update(sample_request) @@ -83219,30 +83127,26 @@ def test_list_rollup_property_source_links_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListRollupPropertySourceLinksResponse.pb( - return_value - ) + return_value = event_create_and_edit.EventEditRule.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_rollup_property_source_links(**mock_args) + client.create_event_edit_rule(**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=properties/*}/rollupPropertySourceLinks" + "%s/v1alpha/{parent=properties/*/dataStreams/*}/eventEditRules" % client.transport._host, args[1], ) -def test_list_rollup_property_source_links_rest_flattened_error( - transport: str = "rest", -): +def test_create_event_edit_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -83251,79 +83155,14 @@ def test_list_rollup_property_source_links_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_rollup_property_source_links( - analytics_admin.ListRollupPropertySourceLinksRequest(), + client.create_event_edit_rule( + analytics_admin.CreateEventEditRuleRequest(), parent="parent_value", + event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), ) -def test_list_rollup_property_source_links_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListRollupPropertySourceLinksResponse( - rollup_property_source_links=[ - resources.RollupPropertySourceLink(), - resources.RollupPropertySourceLink(), - resources.RollupPropertySourceLink(), - ], - next_page_token="abc", - ), - analytics_admin.ListRollupPropertySourceLinksResponse( - rollup_property_source_links=[], - next_page_token="def", - ), - analytics_admin.ListRollupPropertySourceLinksResponse( - rollup_property_source_links=[ - resources.RollupPropertySourceLink(), - ], - next_page_token="ghi", - ), - analytics_admin.ListRollupPropertySourceLinksResponse( - rollup_property_source_links=[ - resources.RollupPropertySourceLink(), - resources.RollupPropertySourceLink(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListRollupPropertySourceLinksResponse.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": "properties/sample1"} - - pager = client.list_rollup_property_source_links(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, resources.RollupPropertySourceLink) for i in results) - - pages = list( - client.list_rollup_property_source_links(request=sample_request).pages - ) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_create_rollup_property_source_link_rest_use_cached_wrapped_rpc(): +def test_update_event_edit_rule_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: @@ -83338,7 +83177,7 @@ def test_create_rollup_property_source_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_rollup_property_source_link + client._transport.update_event_edit_rule in client._transport._wrapped_methods ) @@ -83348,29 +83187,28 @@ def test_create_rollup_property_source_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_rollup_property_source_link + client._transport.update_event_edit_rule ] = mock_rpc request = {} - client.create_rollup_property_source_link(request) + client.update_event_edit_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_rollup_property_source_link(request) + client.update_event_edit_rule(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_rollup_property_source_link_rest_required_fields( - request_type=analytics_admin.CreateRollupPropertySourceLinkRequest, +def test_update_event_edit_rule_rest_required_fields( + request_type=analytics_admin.UpdateEventEditRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -83381,21 +83219,19 @@ def test_create_rollup_property_source_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_rollup_property_source_link._get_unset_required_fields(jsonified_request) + ).update_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_rollup_property_source_link._get_unset_required_fields(jsonified_request) + ).update_event_edit_rule._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -83404,7 +83240,7 @@ def test_create_rollup_property_source_link_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = resources.RollupPropertySourceLink() + return_value = event_create_and_edit.EventEditRule() # 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 @@ -83416,7 +83252,7 @@ def test_create_rollup_property_source_link_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -83426,40 +83262,38 @@ def test_create_rollup_property_source_link_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.RollupPropertySourceLink.pb(return_value) + return_value = event_create_and_edit.EventEditRule.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.create_rollup_property_source_link(request) + response = client.update_event_edit_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_rollup_property_source_link_rest_unset_required_fields(): +def test_update_event_edit_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.create_rollup_property_source_link._get_unset_required_fields({}) - ) + unset_fields = transport.update_event_edit_rule._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) + set(("updateMask",)) & set( ( - "parent", - "rollupPropertySourceLink", + "eventEditRule", + "updateMask", ) ) ) -def test_create_rollup_property_source_link_rest_flattened(): +def test_update_event_edit_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -83468,17 +83302,19 @@ def test_create_rollup_property_source_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.RollupPropertySourceLink() + return_value = event_create_and_edit.EventEditRule() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "event_edit_rule": { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + } + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - rollup_property_source_link=resources.RollupPropertySourceLink( - name="name_value" - ), + event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -83486,28 +83322,26 @@ def test_create_rollup_property_source_link_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.RollupPropertySourceLink.pb(return_value) + return_value = event_create_and_edit.EventEditRule.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_rollup_property_source_link(**mock_args) + client.update_event_edit_rule(**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=properties/*}/rollupPropertySourceLinks" + "%s/v1alpha/{event_edit_rule.name=properties/*/dataStreams/*/eventEditRules/*}" % client.transport._host, args[1], ) -def test_create_rollup_property_source_link_rest_flattened_error( - transport: str = "rest", -): +def test_update_event_edit_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -83516,16 +83350,14 @@ def test_create_rollup_property_source_link_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_rollup_property_source_link( - analytics_admin.CreateRollupPropertySourceLinkRequest(), - parent="parent_value", - rollup_property_source_link=resources.RollupPropertySourceLink( - name="name_value" - ), + client.update_event_edit_rule( + analytics_admin.UpdateEventEditRuleRequest(), + event_edit_rule=event_create_and_edit.EventEditRule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_rollup_property_source_link_rest_use_cached_wrapped_rpc(): +def test_delete_event_edit_rule_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: @@ -83540,7 +83372,7 @@ def test_delete_rollup_property_source_link_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_rollup_property_source_link + client._transport.delete_event_edit_rule in client._transport._wrapped_methods ) @@ -83550,24 +83382,24 @@ def test_delete_rollup_property_source_link_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_rollup_property_source_link + client._transport.delete_event_edit_rule ] = mock_rpc request = {} - client.delete_rollup_property_source_link(request) + client.delete_event_edit_rule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_rollup_property_source_link(request) + client.delete_event_edit_rule(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_rollup_property_source_link_rest_required_fields( - request_type=analytics_admin.DeleteRollupPropertySourceLinkRequest, +def test_delete_event_edit_rule_rest_required_fields( + request_type=analytics_admin.DeleteEventEditRuleRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -83583,7 +83415,7 @@ def test_delete_rollup_property_source_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_rollup_property_source_link._get_unset_required_fields(jsonified_request) + ).delete_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -83592,7 +83424,7 @@ def test_delete_rollup_property_source_link_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_rollup_property_source_link._get_unset_required_fields(jsonified_request) + ).delete_event_edit_rule._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -83631,25 +83463,23 @@ def test_delete_rollup_property_source_link_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_rollup_property_source_link(request) + response = client.delete_event_edit_rule(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_rollup_property_source_link_rest_unset_required_fields(): +def test_delete_event_edit_rule_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = ( - transport.delete_rollup_property_source_link._get_unset_required_fields({}) - ) + unset_fields = transport.delete_event_edit_rule._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_rollup_property_source_link_rest_flattened(): +def test_delete_event_edit_rule_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -83662,7 +83492,7 @@ def test_delete_rollup_property_source_link_rest_flattened(): # get arguments that satisfy an http rule for this method sample_request = { - "name": "properties/sample1/rollupPropertySourceLinks/sample2" + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" } # get truthy value for each flattened field @@ -83679,22 +83509,20 @@ def test_delete_rollup_property_source_link_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_rollup_property_source_link(**mock_args) + client.delete_event_edit_rule(**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=properties/*/rollupPropertySourceLinks/*}" + "%s/v1alpha/{name=properties/*/dataStreams/*/eventEditRules/*}" % client.transport._host, args[1], ) -def test_delete_rollup_property_source_link_rest_flattened_error( - transport: str = "rest", -): +def test_delete_event_edit_rule_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -83703,13 +83531,13 @@ def test_delete_rollup_property_source_link_rest_flattened_error( # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_rollup_property_source_link( - analytics_admin.DeleteRollupPropertySourceLinkRequest(), + client.delete_event_edit_rule( + analytics_admin.DeleteEventEditRuleRequest(), name="name_value", ) -def test_provision_subproperty_rest_use_cached_wrapped_rpc(): +def test_reorder_event_edit_rules_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: @@ -83724,7 +83552,7 @@ def test_provision_subproperty_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.provision_subproperty + client._transport.reorder_event_edit_rules in client._transport._wrapped_methods ) @@ -83734,28 +83562,30 @@ def test_provision_subproperty_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.provision_subproperty + client._transport.reorder_event_edit_rules ] = mock_rpc request = {} - client.provision_subproperty(request) + client.reorder_event_edit_rules(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.provision_subproperty(request) + client.reorder_event_edit_rules(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_provision_subproperty_rest_required_fields( - request_type=analytics_admin.ProvisionSubpropertyRequest, +def test_reorder_event_edit_rules_rest_required_fields( + request_type=analytics_admin.ReorderEventEditRulesRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" + request_init["event_edit_rules"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -83766,17 +83596,24 @@ def test_provision_subproperty_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).provision_subproperty._get_unset_required_fields(jsonified_request) + ).reorder_event_edit_rules._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" + jsonified_request["eventEditRules"] = "event_edit_rules_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).provision_subproperty._get_unset_required_fields(jsonified_request) + ).reorder_event_edit_rules._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 "eventEditRules" in jsonified_request + assert jsonified_request["eventEditRules"] == "event_edit_rules_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -83785,7 +83622,7 @@ def test_provision_subproperty_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ProvisionSubpropertyResponse() + 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 @@ -83805,32 +83642,37 @@ def test_provision_subproperty_rest_required_fields( response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = analytics_admin.ProvisionSubpropertyResponse.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"} - response = client.provision_subproperty(request) + response = client.reorder_event_edit_rules(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_provision_subproperty_rest_unset_required_fields(): +def test_reorder_event_edit_rules_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.provision_subproperty._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("subproperty",))) + unset_fields = transport.reorder_event_edit_rules._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "eventEditRules", + ) + ) + ) -def test_create_subproperty_event_filter_rest_use_cached_wrapped_rpc(): +def test_update_data_redaction_settings_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: @@ -83845,7 +83687,7 @@ def test_create_subproperty_event_filter_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_subproperty_event_filter + client._transport.update_data_redaction_settings in client._transport._wrapped_methods ) @@ -83855,29 +83697,28 @@ def test_create_subproperty_event_filter_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_subproperty_event_filter + client._transport.update_data_redaction_settings ] = mock_rpc request = {} - client.create_subproperty_event_filter(request) + client.update_data_redaction_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_subproperty_event_filter(request) + client.update_data_redaction_settings(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_subproperty_event_filter_rest_required_fields( - request_type=analytics_admin.CreateSubpropertyEventFilterRequest, +def test_update_data_redaction_settings_rest_required_fields( + request_type=analytics_admin.UpdateDataRedactionSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -83888,21 +83729,19 @@ def test_create_subproperty_event_filter_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).update_data_redaction_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).update_data_redaction_settings._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 "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -83911,7 +83750,7 @@ def test_create_subproperty_event_filter_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.DataRedactionSettings() # 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 @@ -83923,7 +83762,7 @@ def test_create_subproperty_event_filter_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "patch", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -83933,42 +83772,40 @@ def test_create_subproperty_event_filter_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.DataRedactionSettings.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.create_subproperty_event_filter(request) + response = client.update_data_redaction_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_subproperty_event_filter_rest_unset_required_fields(): +def test_update_data_redaction_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_subproperty_event_filter._get_unset_required_fields( + unset_fields = transport.update_data_redaction_settings._get_unset_required_fields( {} ) assert set(unset_fields) == ( - set(()) + set(("updateMask",)) & set( ( - "parent", - "subpropertyEventFilter", + "dataRedactionSettings", + "updateMask", ) ) ) -def test_create_subproperty_event_filter_rest_flattened(): +def test_update_data_redaction_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -83977,17 +83814,19 @@ def test_create_subproperty_event_filter_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 = gaa_subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.DataRedactionSettings() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = { + "data_redaction_settings": { + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" + } + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( - name="name_value" - ), + data_redaction_settings=resources.DataRedactionSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -83995,28 +83834,26 @@ def test_create_subproperty_event_filter_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.DataRedactionSettings.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_subproperty_event_filter(**mock_args) + client.update_data_redaction_settings(**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=properties/*}/subpropertyEventFilters" + "%s/v1alpha/{data_redaction_settings.name=properties/*/dataStreams/*/dataRedactionSettings}" % client.transport._host, args[1], ) -def test_create_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): +def test_update_data_redaction_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -84025,16 +83862,14 @@ def test_create_subproperty_event_filter_rest_flattened_error(transport: str = " # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_subproperty_event_filter( - analytics_admin.CreateSubpropertyEventFilterRequest(), - parent="parent_value", - subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( - name="name_value" - ), + client.update_data_redaction_settings( + analytics_admin.UpdateDataRedactionSettingsRequest(), + data_redaction_settings=resources.DataRedactionSettings(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_subproperty_event_filter_rest_use_cached_wrapped_rpc(): +def test_get_data_redaction_settings_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: @@ -84049,7 +83884,7 @@ def test_get_subproperty_event_filter_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_subproperty_event_filter + client._transport.get_data_redaction_settings in client._transport._wrapped_methods ) @@ -84059,24 +83894,24 @@ def test_get_subproperty_event_filter_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_subproperty_event_filter + client._transport.get_data_redaction_settings ] = mock_rpc request = {} - client.get_subproperty_event_filter(request) + client.get_data_redaction_settings(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_subproperty_event_filter(request) + client.get_data_redaction_settings(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_subproperty_event_filter_rest_required_fields( - request_type=analytics_admin.GetSubpropertyEventFilterRequest, +def test_get_data_redaction_settings_rest_required_fields( + request_type=analytics_admin.GetDataRedactionSettingsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport @@ -84092,7 +83927,7 @@ def test_get_subproperty_event_filter_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).get_data_redaction_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -84101,7 +83936,7 @@ def test_get_subproperty_event_filter_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).get_data_redaction_settings._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -84115,7 +83950,7 @@ def test_get_subproperty_event_filter_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.DataRedactionSettings() # 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 @@ -84136,32 +83971,30 @@ def test_get_subproperty_event_filter_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.DataRedactionSettings.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_subproperty_event_filter(request) + response = client.get_data_redaction_settings(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_subproperty_event_filter_rest_unset_required_fields(): +def test_get_data_redaction_settings_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_subproperty_event_filter._get_unset_required_fields({}) + unset_fields = transport.get_data_redaction_settings._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_subproperty_event_filter_rest_flattened(): +def test_get_data_redaction_settings_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -84170,10 +84003,12 @@ def test_get_subproperty_event_filter_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 = subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.DataRedactionSettings() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/subpropertyEventFilters/sample2"} + sample_request = { + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" + } # get truthy value for each flattened field mock_args = dict( @@ -84185,26 +84020,26 @@ def test_get_subproperty_event_filter_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = subproperty_event_filter.SubpropertyEventFilter.pb(return_value) + return_value = resources.DataRedactionSettings.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_subproperty_event_filter(**mock_args) + client.get_data_redaction_settings(**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=properties/*/subpropertyEventFilters/*}" + "%s/v1alpha/{name=properties/*/dataStreams/*/dataRedactionSettings}" % client.transport._host, args[1], ) -def test_get_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): +def test_get_data_redaction_settings_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -84213,13 +84048,13 @@ def test_get_subproperty_event_filter_rest_flattened_error(transport: str = "res # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_subproperty_event_filter( - analytics_admin.GetSubpropertyEventFilterRequest(), + client.get_data_redaction_settings( + analytics_admin.GetDataRedactionSettingsRequest(), name="name_value", ) -def test_list_subproperty_event_filters_rest_use_cached_wrapped_rpc(): +def test_get_calculated_metric_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: @@ -84234,7 +84069,7 @@ def test_list_subproperty_event_filters_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_subproperty_event_filters + client._transport.get_calculated_metric in client._transport._wrapped_methods ) @@ -84244,29 +84079,29 @@ def test_list_subproperty_event_filters_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_subproperty_event_filters + client._transport.get_calculated_metric ] = mock_rpc request = {} - client.list_subproperty_event_filters(request) + client.get_calculated_metric(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_subproperty_event_filters(request) + client.get_calculated_metric(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_subproperty_event_filters_rest_required_fields( - request_type=analytics_admin.ListSubpropertyEventFiltersRequest, +def test_get_calculated_metric_rest_required_fields( + request_type=analytics_admin.GetCalculatedMetricRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -84277,28 +84112,21 @@ def test_list_subproperty_event_filters_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_subproperty_event_filters._get_unset_required_fields(jsonified_request) + ).get_calculated_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_subproperty_event_filters._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "page_size", - "page_token", - ) - ) + ).get_calculated_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -84307,7 +84135,7 @@ def test_list_subproperty_event_filters_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListSubpropertyEventFiltersResponse() + return_value = resources.CalculatedMetric() # 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 @@ -84328,42 +84156,30 @@ def test_list_subproperty_event_filters_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListSubpropertyEventFiltersResponse.pb( - return_value - ) + return_value = resources.CalculatedMetric.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_subproperty_event_filters(request) + response = client.get_calculated_metric(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_subproperty_event_filters_rest_unset_required_fields(): +def test_get_calculated_metric_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_subproperty_event_filters._get_unset_required_fields( - {} - ) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + unset_fields = transport.get_calculated_metric._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_subproperty_event_filters_rest_flattened(): +def test_get_calculated_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -84372,14 +84188,14 @@ def test_list_subproperty_event_filters_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 = analytics_admin.ListSubpropertyEventFiltersResponse() + return_value = resources.CalculatedMetric() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "properties/sample1"} + sample_request = {"name": "properties/sample1/calculatedMetrics/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) @@ -84387,28 +84203,26 @@ def test_list_subproperty_event_filters_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListSubpropertyEventFiltersResponse.pb( - return_value - ) + return_value = resources.CalculatedMetric.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_subproperty_event_filters(**mock_args) + client.get_calculated_metric(**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=properties/*}/subpropertyEventFilters" + "%s/v1alpha/{name=properties/*/calculatedMetrics/*}" % client.transport._host, args[1], ) -def test_list_subproperty_event_filters_rest_flattened_error(transport: str = "rest"): +def test_get_calculated_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -84417,82 +84231,13 @@ def test_list_subproperty_event_filters_rest_flattened_error(transport: str = "r # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_subproperty_event_filters( - analytics_admin.ListSubpropertyEventFiltersRequest(), - parent="parent_value", - ) - - -def test_list_subproperty_event_filters_rest_pager(transport: str = "rest"): - client = AnalyticsAdminServiceClient( - 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 = ( - analytics_admin.ListSubpropertyEventFiltersResponse( - subproperty_event_filters=[ - subproperty_event_filter.SubpropertyEventFilter(), - subproperty_event_filter.SubpropertyEventFilter(), - subproperty_event_filter.SubpropertyEventFilter(), - ], - next_page_token="abc", - ), - analytics_admin.ListSubpropertyEventFiltersResponse( - subproperty_event_filters=[], - next_page_token="def", - ), - analytics_admin.ListSubpropertyEventFiltersResponse( - subproperty_event_filters=[ - subproperty_event_filter.SubpropertyEventFilter(), - ], - next_page_token="ghi", - ), - analytics_admin.ListSubpropertyEventFiltersResponse( - subproperty_event_filters=[ - subproperty_event_filter.SubpropertyEventFilter(), - subproperty_event_filter.SubpropertyEventFilter(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - analytics_admin.ListSubpropertyEventFiltersResponse.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": "properties/sample1"} - - pager = client.list_subproperty_event_filters(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all( - isinstance(i, subproperty_event_filter.SubpropertyEventFilter) - for i in results - ) - - pages = list( - client.list_subproperty_event_filters(request=sample_request).pages + client.get_calculated_metric( + analytics_admin.GetCalculatedMetricRequest(), + name="name_value", ) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_update_subproperty_event_filter_rest_use_cached_wrapped_rpc(): +def test_create_calculated_metric_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: @@ -84507,7 +84252,7 @@ def test_update_subproperty_event_filter_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_subproperty_event_filter + client._transport.create_calculated_metric in client._transport._wrapped_methods ) @@ -84517,28 +84262,30 @@ def test_update_subproperty_event_filter_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_subproperty_event_filter + client._transport.create_calculated_metric ] = mock_rpc request = {} - client.update_subproperty_event_filter(request) + client.create_calculated_metric(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_subproperty_event_filter(request) + client.create_calculated_metric(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_subproperty_event_filter_rest_required_fields( - request_type=analytics_admin.UpdateSubpropertyEventFilterRequest, +def test_create_calculated_metric_rest_required_fields( + request_type=analytics_admin.CreateCalculatedMetricRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} + request_init["parent"] = "" + request_init["calculated_metric_id"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -84546,22 +84293,34 @@ def test_update_subproperty_event_filter_rest_required_fields( ) # verify fields with default values are dropped + assert "calculatedMetricId" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).create_calculated_metric._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "calculatedMetricId" in jsonified_request + assert ( + jsonified_request["calculatedMetricId"] == request_init["calculated_metric_id"] + ) + + jsonified_request["parent"] = "parent_value" + jsonified_request["calculatedMetricId"] = "calculated_metric_id_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).create_calculated_metric._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(("calculated_metric_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 "calculatedMetricId" in jsonified_request + assert jsonified_request["calculatedMetricId"] == "calculated_metric_id_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -84570,7 +84329,7 @@ def test_update_subproperty_event_filter_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.CalculatedMetric() # 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 @@ -84582,7 +84341,7 @@ def test_update_subproperty_event_filter_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "post", "query_params": pb_request, } transcode_result["body"] = pb_request @@ -84592,42 +84351,45 @@ def test_update_subproperty_event_filter_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.CalculatedMetric.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_subproperty_event_filter(request) + response = client.create_calculated_metric(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "calculatedMetricId", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_subproperty_event_filter_rest_unset_required_fields(): +def test_create_calculated_metric_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_subproperty_event_filter._get_unset_required_fields( - {} - ) + unset_fields = transport.create_calculated_metric._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("updateMask",)) + set(("calculatedMetricId",)) & set( ( - "subpropertyEventFilter", - "updateMask", + "parent", + "calculatedMetricId", + "calculatedMetric", ) ) ) -def test_update_subproperty_event_filter_rest_flattened(): +def test_create_calculated_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -84636,21 +84398,16 @@ def test_update_subproperty_event_filter_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 = gaa_subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.CalculatedMetric() # get arguments that satisfy an http rule for this method - sample_request = { - "subproperty_event_filter": { - "name": "properties/sample1/subpropertyEventFilters/sample2" - } - } + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", + calculated_metric=resources.CalculatedMetric(name="name_value"), + calculated_metric_id="calculated_metric_id_value", ) mock_args.update(sample_request) @@ -84658,28 +84415,26 @@ def test_update_subproperty_event_filter_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.CalculatedMetric.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.update_subproperty_event_filter(**mock_args) + client.create_calculated_metric(**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/{subproperty_event_filter.name=properties/*/subpropertyEventFilters/*}" + "%s/v1alpha/{parent=properties/*}/calculatedMetrics" % client.transport._host, args[1], ) -def test_update_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): +def test_create_calculated_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -84688,16 +84443,15 @@ def test_update_subproperty_event_filter_rest_flattened_error(transport: str = " # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_subproperty_event_filter( - analytics_admin.UpdateSubpropertyEventFilterRequest(), - subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( - name="name_value" - ), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.create_calculated_metric( + analytics_admin.CreateCalculatedMetricRequest(), + parent="parent_value", + calculated_metric=resources.CalculatedMetric(name="name_value"), + calculated_metric_id="calculated_metric_id_value", ) -def test_delete_subproperty_event_filter_rest_use_cached_wrapped_rpc(): +def test_list_calculated_metrics_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: @@ -84712,7 +84466,7 @@ def test_delete_subproperty_event_filter_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_subproperty_event_filter + client._transport.list_calculated_metrics in client._transport._wrapped_methods ) @@ -84722,29 +84476,29 @@ def test_delete_subproperty_event_filter_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_subproperty_event_filter + client._transport.list_calculated_metrics ] = mock_rpc request = {} - client.delete_subproperty_event_filter(request) + client.list_calculated_metrics(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_subproperty_event_filter(request) + client.list_calculated_metrics(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_subproperty_event_filter_rest_required_fields( - request_type=analytics_admin.DeleteSubpropertyEventFilterRequest, +def test_list_calculated_metrics_rest_required_fields( + request_type=analytics_admin.ListCalculatedMetricsRequest, ): transport_class = transports.AnalyticsAdminServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -84755,21 +84509,28 @@ def test_delete_subproperty_event_filter_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).list_calculated_metrics._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["name"] = "name_value" + jsonified_request["parent"] = "parent_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_subproperty_event_filter._get_unset_required_fields(jsonified_request) + ).list_calculated_metrics._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -84778,7 +84539,7 @@ def test_delete_subproperty_event_filter_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.ListCalculatedMetricsResponse() # 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 @@ -84790,38 +84551,49 @@ def test_delete_subproperty_event_filter_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 - json_return_value = "" + + # Convert return value to protobuf type + return_value = analytics_admin.ListCalculatedMetricsResponse.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_subproperty_event_filter(request) + response = client.list_calculated_metrics(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_subproperty_event_filter_rest_unset_required_fields(): +def test_list_calculated_metrics_rest_unset_required_fields(): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_subproperty_event_filter._get_unset_required_fields( - {} + unset_fields = transport.list_calculated_metrics._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) ) - assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_subproperty_event_filter_rest_flattened(): +def test_list_calculated_metrics_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -84830,39 +84602,41 @@ def test_delete_subproperty_event_filter_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 = analytics_admin.ListCalculatedMetricsResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "properties/sample1/subpropertyEventFilters/sample2"} + sample_request = {"parent": "properties/sample1"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_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 = analytics_admin.ListCalculatedMetricsResponse.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_subproperty_event_filter(**mock_args) + client.list_calculated_metrics(**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=properties/*/subpropertyEventFilters/*}" + "%s/v1alpha/{parent=properties/*}/calculatedMetrics" % client.transport._host, args[1], ) -def test_delete_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): +def test_list_calculated_metrics_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -84871,3462 +84645,3990 @@ def test_delete_subproperty_event_filter_rest_flattened_error(transport: str = " # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_subproperty_event_filter( - analytics_admin.DeleteSubpropertyEventFilterRequest(), - name="name_value", + client.list_calculated_metrics( + analytics_admin.ListCalculatedMetricsRequest(), + parent="parent_value", ) -def test_credentials_transport_error(): - # It is an error to provide credentials and a transport instance. - transport = transports.AnalyticsAdminServiceGrpcTransport( +def test_list_calculated_metrics_rest_pager(transport: str = "rest"): + client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - with pytest.raises(ValueError): - client = AnalyticsAdminServiceClient( - 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 = ( + analytics_admin.ListCalculatedMetricsResponse( + calculated_metrics=[ + resources.CalculatedMetric(), + resources.CalculatedMetric(), + resources.CalculatedMetric(), + ], + next_page_token="abc", + ), + analytics_admin.ListCalculatedMetricsResponse( + calculated_metrics=[], + next_page_token="def", + ), + analytics_admin.ListCalculatedMetricsResponse( + calculated_metrics=[ + resources.CalculatedMetric(), + ], + next_page_token="ghi", + ), + analytics_admin.ListCalculatedMetricsResponse( + calculated_metrics=[ + resources.CalculatedMetric(), + resources.CalculatedMetric(), + ], + ), ) + # Two responses for two calls + response = response + response - # It is an error to provide a credentials file and a transport instance. - transport = transports.AnalyticsAdminServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = AnalyticsAdminServiceClient( - client_options={"credentials_file": "credentials.json"}, - transport=transport, + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListCalculatedMetricsResponse.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 - # It is an error to provide an api_key and a transport instance. - transport = transports.AnalyticsAdminServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - options = client_options.ClientOptions() - options.api_key = "api_key" - with pytest.raises(ValueError): + sample_request = {"parent": "properties/sample1"} + + pager = client.list_calculated_metrics(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.CalculatedMetric) for i in results) + + pages = list(client.list_calculated_metrics(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_update_calculated_metric_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 = AnalyticsAdminServiceClient( - client_options=options, - transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - # 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 = AnalyticsAdminServiceClient( - client_options=options, credentials=ga_credentials.AnonymousCredentials() + # 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_calculated_metric + in client._transport._wrapped_methods ) - # It is an error to provide scopes and a transport instance. - transport = transports.AnalyticsAdminServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = AnalyticsAdminServiceClient( - client_options={"scopes": ["1", "2"]}, - transport=transport, + # 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_calculated_metric + ] = mock_rpc + request = {} + client.update_calculated_metric(request) -def test_transport_instance(): - # A client may be instantiated with a custom transport instance. - transport = transports.AnalyticsAdminServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - client = AnalyticsAdminServiceClient(transport=transport) - assert client.transport is transport + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.update_calculated_metric(request) -def test_transport_get_channel(): - # A client may be instantiated with a custom transport instance. - transport = transports.AnalyticsAdminServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - channel = transport.grpc_channel - assert channel + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - transport = transports.AnalyticsAdminServiceGrpcAsyncIOTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - channel = transport.grpc_channel - assert channel +def test_update_calculated_metric_rest_required_fields( + request_type=analytics_admin.UpdateCalculatedMetricRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport -@pytest.mark.parametrize( - "transport_class", - [ - transports.AnalyticsAdminServiceGrpcTransport, - transports.AnalyticsAdminServiceGrpcAsyncIOTransport, - transports.AnalyticsAdminServiceRestTransport, - ], -) -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() + 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 -def test_transport_kind_grpc(): - transport = AnalyticsAdminServiceClient.get_transport_class("grpc")( + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ) - assert transport.kind == "grpc" + ).update_calculated_metric._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + # verify required fields with default values are now present -def test_initialize_client_w_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc" - ) - assert client is not None + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_calculated_metric._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 -# 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_account_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_account), "__call__") as call: - call.return_value = resources.Account() - client.get_account(request=None) + # Designate an appropriate value for the returned response. + return_value = resources.CalculatedMetric() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAccountRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = resources.CalculatedMetric.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"} -# 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_accounts_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.update_calculated_metric(request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_accounts), "__call__") as call: - call.return_value = analytics_admin.ListAccountsResponse() - client.list_accounts(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAccountsRequest() - assert args[0] == request_msg +def test_update_calculated_metric_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.update_calculated_metric._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "calculatedMetric", + "updateMask", + ) + ) + ) -# 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_account_empty_call_grpc(): + +def test_update_calculated_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_account), "__call__") as call: - call.return_value = None - client.delete_account(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteAccountRequest() - - assert args[0] == request_msg + # 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.CalculatedMetric() + # get arguments that satisfy an http rule for this method + sample_request = { + "calculated_metric": { + "name": "properties/sample1/calculatedMetrics/sample2" + } + } -# 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_account_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + calculated_metric=resources.CalculatedMetric(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_account), "__call__") as call: - call.return_value = resources.Account() - client.update_account(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.CalculatedMetric.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAccountRequest() + client.update_calculated_metric(**mock_args) - assert args[0] == request_msg + # 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/{calculated_metric.name=properties/*/calculatedMetrics/*}" + % client.transport._host, + args[1], + ) -# 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_provision_account_ticket_empty_call_grpc(): +def test_update_calculated_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.provision_account_ticket), "__call__" - ) as call: - call.return_value = analytics_admin.ProvisionAccountTicketResponse() - client.provision_account_ticket(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_calculated_metric( + analytics_admin.UpdateCalculatedMetricRequest(), + calculated_metric=resources.CalculatedMetric(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ProvisionAccountTicketRequest() - assert args[0] == request_msg +def test_delete_calculated_metric_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_account_summaries_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.delete_calculated_metric + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_account_summaries), "__call__" - ) as call: - call.return_value = analytics_admin.ListAccountSummariesResponse() - client.list_account_summaries(request=None) + # 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_calculated_metric + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAccountSummariesRequest() + request = {} + client.delete_calculated_metric(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.delete_calculated_metric(request) -# 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_property_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_property), "__call__") as call: - call.return_value = resources.Property() - client.get_property(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetPropertyRequest() +def test_delete_calculated_metric_rest_required_fields( + request_type=analytics_admin.DeleteCalculatedMetricRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_properties_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_calculated_metric._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_properties), "__call__") as call: - call.return_value = analytics_admin.ListPropertiesResponse() - client.list_properties(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListPropertiesRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_calculated_metric._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" -# 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_property_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_property), "__call__") as call: - call.return_value = resources.Property() - client.create_property(request=None) + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreatePropertyRequest() + response_value = Response() + response_value.status_code = 200 + json_return_value = "" - assert args[0] == request_msg + 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_calculated_metric(request) -# 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_property_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_property), "__call__") as call: - call.return_value = resources.Property() - client.delete_property(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeletePropertyRequest() +def test_delete_calculated_metric_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - assert args[0] == request_msg + unset_fields = transport.delete_calculated_metric._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_property_empty_call_grpc(): +def test_delete_calculated_metric_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_property), "__call__") as call: - call.return_value = resources.Property() - client.update_property(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdatePropertyRequest() + # 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 - assert args[0] == request_msg + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/calculatedMetrics/sample2"} + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) -# 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_firebase_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) - - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_firebase_link), "__call__" - ) as call: - call.return_value = resources.FirebaseLink() - client.create_firebase_link(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateFirebaseLinkRequest() + client.delete_calculated_metric(**mock_args) - assert args[0] == request_msg + # 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=properties/*/calculatedMetrics/*}" + % client.transport._host, + args[1], + ) -# 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_firebase_link_empty_call_grpc(): +def test_delete_calculated_metric_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_firebase_link), "__call__" - ) as call: - call.return_value = None - client.delete_firebase_link(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteFirebaseLinkRequest() - - assert args[0] == request_msg + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_calculated_metric( + analytics_admin.DeleteCalculatedMetricRequest(), + name="name_value", + ) -# 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_firebase_links_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) +def test_create_rollup_property_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_firebase_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListFirebaseLinksResponse() - client.list_firebase_links(request=None) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListFirebaseLinksRequest() + # Ensure method has been cached + assert ( + client._transport.create_rollup_property + in client._transport._wrapped_methods + ) - assert args[0] == request_msg + # 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_rollup_property + ] = mock_rpc + request = {} + client.create_rollup_property(request) -# 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_global_site_tag_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_global_site_tag), "__call__" - ) as call: - call.return_value = resources.GlobalSiteTag() - client.get_global_site_tag(request=None) + client.create_rollup_property(request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetGlobalSiteTagRequest() + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - assert args[0] == request_msg +def test_create_rollup_property_rest_required_fields( + request_type=analytics_admin.CreateRollupPropertyRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport -# 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_google_ads_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_google_ads_link), "__call__" - ) as call: - call.return_value = resources.GoogleAdsLink() - client.create_google_ads_link(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateGoogleAdsLinkRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_rollup_property._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_rollup_property._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone -# 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_google_ads_link_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_google_ads_link), "__call__" - ) as call: - call.return_value = resources.GoogleAdsLink() - client.update_google_ads_link(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateGoogleAdsLinkRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = analytics_admin.CreateRollupPropertyResponse() + # 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 -# 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_google_ads_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = analytics_admin.CreateRollupPropertyResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_google_ads_link), "__call__" - ) as call: - call.return_value = None - client.delete_google_ads_link(request=None) + 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 underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteGoogleAdsLinkRequest() + response = client.create_rollup_property(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# 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_google_ads_links_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_create_rollup_property_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_google_ads_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListGoogleAdsLinksResponse() - client.list_google_ads_links(request=None) + unset_fields = transport.create_rollup_property._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("rollupProperty",))) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListGoogleAdsLinksRequest() - assert args[0] == request_msg +def test_get_rollup_property_source_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_data_sharing_settings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.get_rollup_property_source_link + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_data_sharing_settings), "__call__" - ) as call: - call.return_value = resources.DataSharingSettings() - client.get_data_sharing_settings(request=None) + # 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_rollup_property_source_link + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataSharingSettingsRequest() + request = {} + client.get_rollup_property_source_link(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.get_rollup_property_source_link(request) -# 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_measurement_protocol_secret_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_measurement_protocol_secret), "__call__" - ) as call: - call.return_value = resources.MeasurementProtocolSecret() - client.get_measurement_protocol_secret(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetMeasurementProtocolSecretRequest() +def test_get_rollup_property_source_link_rest_required_fields( + request_type=analytics_admin.GetRollupPropertySourceLinkRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_measurement_protocol_secrets_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_rollup_property_source_link._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_measurement_protocol_secrets), "__call__" - ) as call: - call.return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() - client.list_measurement_protocol_secrets(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListMeasurementProtocolSecretsRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_rollup_property_source_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" -# 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_measurement_protocol_secret_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_measurement_protocol_secret), "__call__" - ) as call: - call.return_value = resources.MeasurementProtocolSecret() - client.create_measurement_protocol_secret(request=None) + # Designate an appropriate value for the returned response. + return_value = resources.RollupPropertySourceLink() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateMeasurementProtocolSecretRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = resources.RollupPropertySourceLink.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"} -# 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_measurement_protocol_secret_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.get_rollup_property_source_link(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_measurement_protocol_secret), "__call__" - ) as call: - call.return_value = None - client.delete_measurement_protocol_secret(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteMeasurementProtocolSecretRequest() - assert args[0] == request_msg +def test_get_rollup_property_source_link_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.get_rollup_property_source_link._get_unset_required_fields( + {} + ) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_measurement_protocol_secret_empty_call_grpc(): + +def test_get_rollup_property_source_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_measurement_protocol_secret), "__call__" - ) as call: - call.return_value = resources.MeasurementProtocolSecret() - client.update_measurement_protocol_secret(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateMeasurementProtocolSecretRequest() - - assert args[0] == request_msg + # 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.RollupPropertySourceLink() + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "properties/sample1/rollupPropertySourceLinks/sample2" + } -# 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_acknowledge_user_data_collection_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.acknowledge_user_data_collection), "__call__" - ) as call: - call.return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() - client.acknowledge_user_data_collection(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.RollupPropertySourceLink.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.AcknowledgeUserDataCollectionRequest() + client.get_rollup_property_source_link(**mock_args) - assert args[0] == request_msg + # 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=properties/*/rollupPropertySourceLinks/*}" + % client.transport._host, + args[1], + ) -# 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_sk_ad_network_conversion_value_schema_empty_call_grpc(): +def test_get_rollup_property_source_link_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_sk_ad_network_conversion_value_schema), "__call__" - ) as call: - call.return_value = resources.SKAdNetworkConversionValueSchema() - client.get_sk_ad_network_conversion_value_schema(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_rollup_property_source_link( + analytics_admin.GetRollupPropertySourceLinkRequest(), + name="name_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() - assert args[0] == request_msg +def test_list_rollup_property_source_links_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_sk_ad_network_conversion_value_schema_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.list_rollup_property_source_links + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_sk_ad_network_conversion_value_schema), "__call__" - ) as call: - call.return_value = resources.SKAdNetworkConversionValueSchema() - client.create_sk_ad_network_conversion_value_schema(request=None) + # 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_rollup_property_source_links + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() + request = {} + client.list_rollup_property_source_links(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.list_rollup_property_source_links(request) -# 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_sk_ad_network_conversion_value_schema_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_sk_ad_network_conversion_value_schema), "__call__" - ) as call: - call.return_value = None - client.delete_sk_ad_network_conversion_value_schema(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() +def test_list_rollup_property_source_links_rest_required_fields( + request_type=analytics_admin.ListRollupPropertySourceLinksRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_sk_ad_network_conversion_value_schema_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_rollup_property_source_links._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_sk_ad_network_conversion_value_schema), "__call__" - ) as call: - call.return_value = resources.SKAdNetworkConversionValueSchema() - client.update_sk_ad_network_conversion_value_schema(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() + jsonified_request["parent"] = "parent_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_rollup_property_source_links._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" -# 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_sk_ad_network_conversion_value_schemas_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_sk_ad_network_conversion_value_schemas), "__call__" - ) as call: - call.return_value = ( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() - ) - client.list_sk_ad_network_conversion_value_schemas(request=None) + # Designate an appropriate value for the returned response. + return_value = analytics_admin.ListRollupPropertySourceLinksResponse() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = analytics_admin.ListRollupPropertySourceLinksResponse.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"} -# 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_search_change_history_events_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.list_rollup_property_source_links(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.search_change_history_events), "__call__" - ) as call: - call.return_value = analytics_admin.SearchChangeHistoryEventsResponse() - client.search_change_history_events(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.SearchChangeHistoryEventsRequest() - assert args[0] == request_msg +def test_list_rollup_property_source_links_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = ( + transport.list_rollup_property_source_links._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -# 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_google_signals_settings_empty_call_grpc(): + +def test_list_rollup_property_source_links_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_google_signals_settings), "__call__" - ) as call: - call.return_value = resources.GoogleSignalsSettings() - client.get_google_signals_settings(request=None) + # 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 = analytics_admin.ListRollupPropertySourceLinksResponse() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetGoogleSignalsSettingsRequest() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} - assert args[0] == request_msg + # 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 = analytics_admin.ListRollupPropertySourceLinksResponse.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_rollup_property_source_links(**mock_args) -# 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_google_signals_settings_empty_call_grpc(): + # 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=properties/*}/rollupPropertySourceLinks" + % client.transport._host, + args[1], + ) + + +def test_list_rollup_property_source_links_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_google_signals_settings), "__call__" - ) as call: - call.return_value = resources.GoogleSignalsSettings() - client.update_google_signals_settings(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateGoogleSignalsSettingsRequest() - - assert args[0] == request_msg + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_rollup_property_source_links( + analytics_admin.ListRollupPropertySourceLinksRequest(), + parent="parent_value", + ) -# 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_conversion_event_empty_call_grpc(): +def test_list_rollup_property_source_links_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_conversion_event), "__call__" - ) as call: - call.return_value = resources.ConversionEvent() - client.create_conversion_event(request=None) + # 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 = ( + analytics_admin.ListRollupPropertySourceLinksResponse( + rollup_property_source_links=[ + resources.RollupPropertySourceLink(), + resources.RollupPropertySourceLink(), + resources.RollupPropertySourceLink(), + ], + next_page_token="abc", + ), + analytics_admin.ListRollupPropertySourceLinksResponse( + rollup_property_source_links=[], + next_page_token="def", + ), + analytics_admin.ListRollupPropertySourceLinksResponse( + rollup_property_source_links=[ + resources.RollupPropertySourceLink(), + ], + next_page_token="ghi", + ), + analytics_admin.ListRollupPropertySourceLinksResponse( + rollup_property_source_links=[ + resources.RollupPropertySourceLink(), + resources.RollupPropertySourceLink(), + ], + ), + ) + # Two responses for two calls + response = response + response - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateConversionEventRequest() + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListRollupPropertySourceLinksResponse.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 - assert args[0] == request_msg + sample_request = {"parent": "properties/sample1"} + pager = client.list_rollup_property_source_links(request=sample_request) -# 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_conversion_event_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.RollupPropertySourceLink) for i in results) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_conversion_event), "__call__" - ) as call: - call.return_value = resources.ConversionEvent() - client.update_conversion_event(request=None) + pages = list( + client.list_rollup_property_source_links(request=sample_request).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateConversionEventRequest() - assert args[0] == request_msg +def test_create_rollup_property_source_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_conversion_event_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.create_rollup_property_source_link + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_conversion_event), "__call__" - ) as call: - call.return_value = resources.ConversionEvent() - client.get_conversion_event(request=None) + # 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_rollup_property_source_link + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetConversionEventRequest() + request = {} + client.create_rollup_property_source_link(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.create_rollup_property_source_link(request) -# 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_conversion_event_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_conversion_event), "__call__" - ) as call: - call.return_value = None - client.delete_conversion_event(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteConversionEventRequest() +def test_create_rollup_property_source_link_rest_required_fields( + request_type=analytics_admin.CreateRollupPropertySourceLinkRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_conversion_events_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_rollup_property_source_link._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_conversion_events), "__call__" - ) as call: - call.return_value = analytics_admin.ListConversionEventsResponse() - client.list_conversion_events(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListConversionEventsRequest() + jsonified_request["parent"] = "parent_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_rollup_property_source_link._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" -# 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_key_event_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_key_event), "__call__") as call: - call.return_value = resources.KeyEvent() - client.create_key_event(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateKeyEventRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = resources.RollupPropertySourceLink() + # 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 -# 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_key_event_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = resources.RollupPropertySourceLink.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_key_event), "__call__") as call: - call.return_value = resources.KeyEvent() - client.update_key_event(request=None) + 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 underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateKeyEventRequest() + response = client.create_rollup_property_source_link(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# 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_key_event_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_create_rollup_property_source_link_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_key_event), "__call__") as call: - call.return_value = resources.KeyEvent() - client.get_key_event(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetKeyEventRequest() - - assert args[0] == request_msg + unset_fields = ( + transport.create_rollup_property_source_link._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "rollupPropertySourceLink", + ) + ) + ) -# 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_key_event_empty_call_grpc(): +def test_create_rollup_property_source_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_key_event), "__call__") as call: - call.return_value = None - client.delete_key_event(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteKeyEventRequest() - - assert args[0] == request_msg + # 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.RollupPropertySourceLink() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} -# 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_key_events_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + rollup_property_source_link=resources.RollupPropertySourceLink( + name="name_value" + ), + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_key_events), "__call__") as call: - call.return_value = analytics_admin.ListKeyEventsResponse() - client.list_key_events(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.RollupPropertySourceLink.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListKeyEventsRequest() + client.create_rollup_property_source_link(**mock_args) - assert args[0] == request_msg + # 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=properties/*}/rollupPropertySourceLinks" + % client.transport._host, + args[1], + ) -# 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_display_video360_advertiser_link_empty_call_grpc(): +def test_create_rollup_property_source_link_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_display_video360_advertiser_link), "__call__" - ) as call: - call.return_value = resources.DisplayVideo360AdvertiserLink() - client.get_display_video360_advertiser_link(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_rollup_property_source_link( + analytics_admin.CreateRollupPropertySourceLinkRequest(), + parent="parent_value", + rollup_property_source_link=resources.RollupPropertySourceLink( + name="name_value" + ), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() - assert args[0] == request_msg +def test_delete_rollup_property_source_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_display_video360_advertiser_links_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.delete_rollup_property_source_link + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_display_video360_advertiser_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() - client.list_display_video360_advertiser_links(request=None) + # 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_rollup_property_source_link + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() + request = {} + client.delete_rollup_property_source_link(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.delete_rollup_property_source_link(request) -# 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_display_video360_advertiser_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_display_video360_advertiser_link), "__call__" - ) as call: - call.return_value = resources.DisplayVideo360AdvertiserLink() - client.create_display_video360_advertiser_link(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() +def test_delete_rollup_property_source_link_rest_required_fields( + request_type=analytics_admin.DeleteRollupPropertySourceLinkRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_display_video360_advertiser_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_rollup_property_source_link._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_display_video360_advertiser_link), "__call__" - ) as call: - call.return_value = None - client.delete_display_video360_advertiser_link(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_rollup_property_source_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" -# 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_display_video360_advertiser_link_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_display_video360_advertiser_link), "__call__" - ) as call: - call.return_value = resources.DisplayVideo360AdvertiserLink() - client.update_display_video360_advertiser_link(request=None) + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() + response_value = Response() + response_value.status_code = 200 + json_return_value = "" - assert args[0] == request_msg + 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_rollup_property_source_link(request) -# 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_display_video360_advertiser_link_proposal_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_display_video360_advertiser_link_proposal), "__call__" - ) as call: - call.return_value = resources.DisplayVideo360AdvertiserLinkProposal() - client.get_display_video360_advertiser_link_proposal(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() +def test_delete_rollup_property_source_link_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - assert args[0] == request_msg + unset_fields = ( + transport.delete_rollup_property_source_link._get_unset_required_fields({}) + ) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_display_video360_advertiser_link_proposals_empty_call_grpc(): +def test_delete_rollup_property_source_link_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_display_video360_advertiser_link_proposals), - "__call__", - ) as call: - call.return_value = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() - ) - client.list_display_video360_advertiser_link_proposals(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() - ) + # 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 - assert args[0] == request_msg + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "properties/sample1/rollupPropertySourceLinks/sample2" + } + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) -# 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_display_video360_advertiser_link_proposal_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_display_video360_advertiser_link_proposal), - "__call__", - ) as call: - call.return_value = resources.DisplayVideo360AdvertiserLinkProposal() - client.create_display_video360_advertiser_link_proposal(request=None) + client.delete_rollup_property_source_link(**mock_args) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() + # 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=properties/*/rollupPropertySourceLinks/*}" + % client.transport._host, + args[1], ) - 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_display_video360_advertiser_link_proposal_empty_call_grpc(): +def test_delete_rollup_property_source_link_rest_flattened_error( + transport: str = "rest", +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_display_video360_advertiser_link_proposal), - "__call__", - ) as call: - call.return_value = None - client.delete_display_video360_advertiser_link_proposal(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_rollup_property_source_link( + analytics_admin.DeleteRollupPropertySourceLinkRequest(), + name="name_value", ) - assert args[0] == request_msg +def test_provision_subproperty_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) -# 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_approve_display_video360_advertiser_link_proposal_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.approve_display_video360_advertiser_link_proposal), - "__call__", - ) as call: - call.return_value = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + # Ensure method has been cached + assert ( + client._transport.provision_subproperty + in client._transport._wrapped_methods ) - client.approve_display_video360_advertiser_link_proposal(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() + # 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.provision_subproperty + ] = mock_rpc - assert args[0] == request_msg + request = {} + client.provision_subproperty(request) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 -# 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_cancel_display_video360_advertiser_link_proposal_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) - - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.cancel_display_video360_advertiser_link_proposal), - "__call__", - ) as call: - call.return_value = resources.DisplayVideo360AdvertiserLinkProposal() - client.cancel_display_video360_advertiser_link_proposal(request=None) + client.provision_subproperty(request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - assert args[0] == request_msg +def test_provision_subproperty_rest_required_fields( + request_type=analytics_admin.ProvisionSubpropertyRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport -# 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_custom_dimension_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_custom_dimension), "__call__" - ) as call: - call.return_value = resources.CustomDimension() - client.create_custom_dimension(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateCustomDimensionRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).provision_subproperty._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).provision_subproperty._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + # verify required fields with non-default values are left alone -# 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_custom_dimension_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_custom_dimension), "__call__" - ) as call: - call.return_value = resources.CustomDimension() - client.update_custom_dimension(request=None) + # Designate an appropriate value for the returned response. + return_value = analytics_admin.ProvisionSubpropertyResponse() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateCustomDimensionRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = analytics_admin.ProvisionSubpropertyResponse.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"} -# 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_custom_dimensions_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.provision_subproperty(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_custom_dimensions), "__call__" - ) as call: - call.return_value = analytics_admin.ListCustomDimensionsResponse() - client.list_custom_dimensions(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListCustomDimensionsRequest() - assert args[0] == request_msg +def test_provision_subproperty_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.provision_subproperty._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("subproperty",))) -# 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_archive_custom_dimension_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.archive_custom_dimension), "__call__" - ) as call: - call.return_value = None - client.archive_custom_dimension(request=None) +def test_create_subproperty_event_filter_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ArchiveCustomDimensionRequest() + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - assert args[0] == request_msg + # Ensure method has been cached + assert ( + client._transport.create_subproperty_event_filter + 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_subproperty_event_filter + ] = mock_rpc -# 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_custom_dimension_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + request = {} + client.create_subproperty_event_filter(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_custom_dimension), "__call__" - ) as call: - call.return_value = resources.CustomDimension() - client.get_custom_dimension(request=None) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetCustomDimensionRequest() + client.create_subproperty_event_filter(request) - assert args[0] == request_msg + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 -# 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_custom_metric_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_create_subproperty_event_filter_rest_required_fields( + request_type=analytics_admin.CreateSubpropertyEventFilterRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport + + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_custom_metric), "__call__" - ) as call: - call.return_value = resources.CustomMetric() - client.create_custom_metric(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateCustomMetricRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_subproperty_event_filter._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_subproperty_event_filter._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" -# 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_custom_metric_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_custom_metric), "__call__" - ) as call: - call.return_value = resources.CustomMetric() - client.update_custom_metric(request=None) + # Designate an appropriate value for the returned response. + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateCustomMetricRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.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.create_subproperty_event_filter(request) -# 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_custom_metrics_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_custom_metrics), "__call__" - ) as call: - call.return_value = analytics_admin.ListCustomMetricsResponse() - client.list_custom_metrics(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListCustomMetricsRequest() +def test_create_subproperty_event_filter_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - assert args[0] == request_msg + unset_fields = transport.create_subproperty_event_filter._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "subpropertyEventFilter", + ) + ) + ) -# 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_archive_custom_metric_empty_call_grpc(): +def test_create_subproperty_event_filter_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.archive_custom_metric), "__call__" - ) as call: - call.return_value = None - client.archive_custom_metric(request=None) + # 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 = gaa_subproperty_event_filter.SubpropertyEventFilter() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ArchiveCustomMetricRequest() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} - assert args[0] == request_msg + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( + 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 = gaa_subproperty_event_filter.SubpropertyEventFilter.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_subproperty_event_filter(**mock_args) -# 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_custom_metric_empty_call_grpc(): + # 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=properties/*}/subpropertyEventFilters" + % client.transport._host, + args[1], + ) + + +def test_create_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_custom_metric), "__call__" - ) as call: - call.return_value = resources.CustomMetric() - client.get_custom_metric(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_subproperty_event_filter( + analytics_admin.CreateSubpropertyEventFilterRequest(), + parent="parent_value", + subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( + name="name_value" + ), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetCustomMetricRequest() - assert args[0] == request_msg +def test_get_subproperty_event_filter_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_data_retention_settings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.get_subproperty_event_filter + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_data_retention_settings), "__call__" - ) as call: - call.return_value = resources.DataRetentionSettings() - client.get_data_retention_settings(request=None) + # 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_subproperty_event_filter + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataRetentionSettingsRequest() + request = {} + client.get_subproperty_event_filter(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.get_subproperty_event_filter(request) -# 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_data_retention_settings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + # 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_subproperty_event_filter_rest_required_fields( + request_type=analytics_admin.GetSubpropertyEventFilterRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport + + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_data_retention_settings), "__call__" - ) as call: - call.return_value = resources.DataRetentionSettings() - client.update_data_retention_settings(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDataRetentionSettingsRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_subproperty_event_filter._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_subproperty_event_filter._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" -# 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_data_stream_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_data_stream), "__call__" - ) as call: - call.return_value = resources.DataStream() - client.create_data_stream(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateDataStreamRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = subproperty_event_filter.SubpropertyEventFilter() + # 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 -# 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_data_stream_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = subproperty_event_filter.SubpropertyEventFilter.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_data_stream), "__call__" - ) as call: - call.return_value = None - client.delete_data_stream(request=None) + 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 underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteDataStreamRequest() + response = client.get_subproperty_event_filter(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# 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_data_stream_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_get_subproperty_event_filter_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_data_stream), "__call__" - ) as call: - call.return_value = resources.DataStream() - client.update_data_stream(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDataStreamRequest() - - assert args[0] == request_msg + unset_fields = transport.get_subproperty_event_filter._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_data_streams_empty_call_grpc(): +def test_get_subproperty_event_filter_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_data_streams), "__call__" - ) as call: - call.return_value = analytics_admin.ListDataStreamsResponse() - client.list_data_streams(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListDataStreamsRequest() - - assert args[0] == request_msg + # 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 = subproperty_event_filter.SubpropertyEventFilter() + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/subpropertyEventFilters/sample2"} -# 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_data_stream_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_data_stream), "__call__") as call: - call.return_value = resources.DataStream() - client.get_data_stream(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = subproperty_event_filter.SubpropertyEventFilter.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataStreamRequest() + client.get_subproperty_event_filter(**mock_args) - assert args[0] == request_msg + # 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=properties/*/subpropertyEventFilters/*}" + % client.transport._host, + args[1], + ) -# 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_audience_empty_call_grpc(): +def test_get_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_audience), "__call__") as call: - call.return_value = audience.Audience() - client.get_audience(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAudienceRequest() - - assert args[0] == request_msg + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_subproperty_event_filter( + analytics_admin.GetSubpropertyEventFilterRequest(), + name="name_value", + ) -# 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_audiences_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) +def test_list_subproperty_event_filters_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_audiences), "__call__") as call: - call.return_value = analytics_admin.ListAudiencesResponse() - client.list_audiences(request=None) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAudiencesRequest() + # Ensure method has been cached + assert ( + client._transport.list_subproperty_event_filters + in client._transport._wrapped_methods + ) - assert args[0] == request_msg + # 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_subproperty_event_filters + ] = mock_rpc + request = {} + client.list_subproperty_event_filters(request) -# 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_audience_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_audience), "__call__") as call: - call.return_value = gaa_audience.Audience() - client.create_audience(request=None) + client.list_subproperty_event_filters(request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateAudienceRequest() + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - assert args[0] == request_msg +def test_list_subproperty_event_filters_rest_required_fields( + request_type=analytics_admin.ListSubpropertyEventFiltersRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport -# 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_audience_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_audience), "__call__") as call: - call.return_value = gaa_audience.Audience() - client.update_audience(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAudienceRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_subproperty_event_filters._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" -# 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_archive_audience_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_subproperty_event_filters._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "page_size", + "page_token", + ) ) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.archive_audience), "__call__") as call: - call.return_value = None - client.archive_audience(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ArchiveAudienceRequest() - - assert args[0] == request_msg - + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" -# 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_search_ads360_link_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_search_ads360_link), "__call__" - ) as call: - call.return_value = resources.SearchAds360Link() - client.get_search_ads360_link(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetSearchAds360LinkRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = analytics_admin.ListSubpropertyEventFiltersResponse() + # 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 -# 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_search_ads360_links_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = analytics_admin.ListSubpropertyEventFiltersResponse.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_search_ads360_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListSearchAds360LinksResponse() - client.list_search_ads360_links(request=None) + 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 underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListSearchAds360LinksRequest() + response = client.list_subproperty_event_filters(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# 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_search_ads360_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_list_subproperty_event_filters_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_search_ads360_link), "__call__" - ) as call: - call.return_value = resources.SearchAds360Link() - client.create_search_ads360_link(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateSearchAds360LinkRequest() - - assert args[0] == request_msg + unset_fields = transport.list_subproperty_event_filters._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -# 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_search_ads360_link_empty_call_grpc(): +def test_list_subproperty_event_filters_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_search_ads360_link), "__call__" - ) as call: - call.return_value = None - client.delete_search_ads360_link(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteSearchAds360LinkRequest() - - assert args[0] == request_msg + # 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 = analytics_admin.ListSubpropertyEventFiltersResponse() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} -# 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_search_ads360_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_search_ads360_link), "__call__" - ) as call: - call.return_value = resources.SearchAds360Link() - client.update_search_ads360_link(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = analytics_admin.ListSubpropertyEventFiltersResponse.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateSearchAds360LinkRequest() + client.list_subproperty_event_filters(**mock_args) - assert args[0] == request_msg + # 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=properties/*}/subpropertyEventFilters" + % client.transport._host, + args[1], + ) -# 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_attribution_settings_empty_call_grpc(): +def test_list_subproperty_event_filters_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_attribution_settings), "__call__" - ) as call: - call.return_value = resources.AttributionSettings() - client.get_attribution_settings(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAttributionSettingsRequest() - - assert args[0] == request_msg + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_subproperty_event_filters( + analytics_admin.ListSubpropertyEventFiltersRequest(), + parent="parent_value", + ) -# 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_attribution_settings_empty_call_grpc(): +def test_list_subproperty_event_filters_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_attribution_settings), "__call__" - ) as call: - call.return_value = resources.AttributionSettings() - client.update_attribution_settings(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAttributionSettingsRequest() - - assert args[0] == request_msg + # 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 = ( + analytics_admin.ListSubpropertyEventFiltersResponse( + subproperty_event_filters=[ + subproperty_event_filter.SubpropertyEventFilter(), + subproperty_event_filter.SubpropertyEventFilter(), + subproperty_event_filter.SubpropertyEventFilter(), + ], + next_page_token="abc", + ), + analytics_admin.ListSubpropertyEventFiltersResponse( + subproperty_event_filters=[], + next_page_token="def", + ), + analytics_admin.ListSubpropertyEventFiltersResponse( + subproperty_event_filters=[ + subproperty_event_filter.SubpropertyEventFilter(), + ], + next_page_token="ghi", + ), + analytics_admin.ListSubpropertyEventFiltersResponse( + subproperty_event_filters=[ + subproperty_event_filter.SubpropertyEventFilter(), + subproperty_event_filter.SubpropertyEventFilter(), + ], + ), + ) + # Two responses for two calls + response = response + response + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListSubpropertyEventFiltersResponse.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 -# 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_run_access_report_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + sample_request = {"parent": "properties/sample1"} - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.run_access_report), "__call__" - ) as call: - call.return_value = analytics_admin.RunAccessReportResponse() - client.run_access_report(request=None) + pager = client.list_subproperty_event_filters(request=sample_request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.RunAccessReportRequest() + results = list(pager) + assert len(results) == 6 + assert all( + isinstance(i, subproperty_event_filter.SubpropertyEventFilter) + for i in results + ) - assert args[0] == request_msg + pages = list( + client.list_subproperty_event_filters(request=sample_request).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -# 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_access_binding_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) +def test_update_subproperty_event_filter_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_access_binding), "__call__" - ) as call: - call.return_value = resources.AccessBinding() - client.create_access_binding(request=None) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateAccessBindingRequest() + # Ensure method has been cached + assert ( + client._transport.update_subproperty_event_filter + in client._transport._wrapped_methods + ) - assert args[0] == request_msg + # 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_subproperty_event_filter + ] = mock_rpc + request = {} + client.update_subproperty_event_filter(request) -# 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_access_binding_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_access_binding), "__call__" - ) as call: - call.return_value = resources.AccessBinding() - client.get_access_binding(request=None) + client.update_subproperty_event_filter(request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAccessBindingRequest() + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - assert args[0] == request_msg +def test_update_subproperty_event_filter_rest_required_fields( + request_type=analytics_admin.UpdateSubpropertyEventFilterRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport -# 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_access_binding_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_access_binding), "__call__" - ) as call: - call.return_value = resources.AccessBinding() - client.update_access_binding(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAccessBindingRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_subproperty_event_filter._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_subproperty_event_filter._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 -# 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_access_binding_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_access_binding), "__call__" - ) as call: - call.return_value = None - client.delete_access_binding(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteAccessBindingRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + # 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 -# 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_access_bindings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( + return_value + ) + json_return_value = json_format.MessageToJson(return_value) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_access_bindings), "__call__" - ) as call: - call.return_value = analytics_admin.ListAccessBindingsResponse() - client.list_access_bindings(request=None) + 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 underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAccessBindingsRequest() + response = client.update_subproperty_event_filter(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# 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_batch_create_access_bindings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_update_subproperty_event_filter_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.batch_create_access_bindings), "__call__" - ) as call: - call.return_value = analytics_admin.BatchCreateAccessBindingsResponse() - client.batch_create_access_bindings(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchCreateAccessBindingsRequest() - - assert args[0] == request_msg + unset_fields = transport.update_subproperty_event_filter._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "subpropertyEventFilter", + "updateMask", + ) + ) + ) -# 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_batch_get_access_bindings_empty_call_grpc(): +def test_update_subproperty_event_filter_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.batch_get_access_bindings), "__call__" - ) as call: - call.return_value = analytics_admin.BatchGetAccessBindingsResponse() - client.batch_get_access_bindings(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchGetAccessBindingsRequest() - - assert args[0] == request_msg + # 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 = gaa_subproperty_event_filter.SubpropertyEventFilter() + # get arguments that satisfy an http rule for this method + sample_request = { + "subproperty_event_filter": { + "name": "properties/sample1/subpropertyEventFilters/sample2" + } + } -# 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_batch_update_access_bindings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.batch_update_access_bindings), "__call__" - ) as call: - call.return_value = analytics_admin.BatchUpdateAccessBindingsResponse() - client.batch_update_access_bindings(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchUpdateAccessBindingsRequest() + client.update_subproperty_event_filter(**mock_args) - assert args[0] == request_msg + # 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/{subproperty_event_filter.name=properties/*/subpropertyEventFilters/*}" + % client.transport._host, + args[1], + ) -# 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_batch_delete_access_bindings_empty_call_grpc(): +def test_update_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.batch_delete_access_bindings), "__call__" - ) as call: - call.return_value = None - client.batch_delete_access_bindings(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_subproperty_event_filter( + analytics_admin.UpdateSubpropertyEventFilterRequest(), + subproperty_event_filter=gaa_subproperty_event_filter.SubpropertyEventFilter( + name="name_value" + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchDeleteAccessBindingsRequest() - assert args[0] == request_msg +def test_delete_subproperty_event_filter_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_expanded_data_set_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.delete_subproperty_event_filter + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_expanded_data_set), "__call__" - ) as call: - call.return_value = expanded_data_set.ExpandedDataSet() - client.get_expanded_data_set(request=None) + # 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_subproperty_event_filter + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetExpandedDataSetRequest() + request = {} + client.delete_subproperty_event_filter(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.delete_subproperty_event_filter(request) -# 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_expanded_data_sets_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_expanded_data_sets), "__call__" - ) as call: - call.return_value = analytics_admin.ListExpandedDataSetsResponse() - client.list_expanded_data_sets(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListExpandedDataSetsRequest() +def test_delete_subproperty_event_filter_rest_required_fields( + request_type=analytics_admin.DeleteSubpropertyEventFilterRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_expanded_data_set_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_subproperty_event_filter._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_expanded_data_set), "__call__" - ) as call: - call.return_value = gaa_expanded_data_set.ExpandedDataSet() - client.create_expanded_data_set(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateExpandedDataSetRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_subproperty_event_filter._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" -# 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_expanded_data_set_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_expanded_data_set), "__call__" - ) as call: - call.return_value = gaa_expanded_data_set.ExpandedDataSet() - client.update_expanded_data_set(request=None) + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateExpandedDataSetRequest() + response_value = Response() + response_value.status_code = 200 + json_return_value = "" - assert args[0] == request_msg + 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_subproperty_event_filter(request) -# 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_expanded_data_set_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_expanded_data_set), "__call__" - ) as call: - call.return_value = None - client.delete_expanded_data_set(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteExpandedDataSetRequest() +def test_delete_subproperty_event_filter_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - assert args[0] == request_msg + unset_fields = transport.delete_subproperty_event_filter._get_unset_required_fields( + {} + ) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_channel_group_empty_call_grpc(): +def test_delete_subproperty_event_filter_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_channel_group), "__call__" - ) as call: - call.return_value = channel_group.ChannelGroup() - client.get_channel_group(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetChannelGroupRequest() - - assert args[0] == request_msg + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/subpropertyEventFilters/sample2"} -# 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_channel_groups_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_channel_groups), "__call__" - ) as call: - call.return_value = analytics_admin.ListChannelGroupsResponse() - client.list_channel_groups(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListChannelGroupsRequest() + client.delete_subproperty_event_filter(**mock_args) - assert args[0] == request_msg + # 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=properties/*/subpropertyEventFilters/*}" + % client.transport._host, + args[1], + ) -# 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_channel_group_empty_call_grpc(): +def test_delete_subproperty_event_filter_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_channel_group), "__call__" - ) as call: - call.return_value = gaa_channel_group.ChannelGroup() - client.create_channel_group(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_subproperty_event_filter( + analytics_admin.DeleteSubpropertyEventFilterRequest(), + name="name_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateChannelGroupRequest() - assert args[0] == request_msg +def test_create_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_channel_group_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.create_reporting_data_annotation + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_channel_group), "__call__" - ) as call: - call.return_value = gaa_channel_group.ChannelGroup() - client.update_channel_group(request=None) + # 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_reporting_data_annotation + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateChannelGroupRequest() + request = {} + client.create_reporting_data_annotation(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.create_reporting_data_annotation(request) -# 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_channel_group_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_channel_group), "__call__" - ) as call: - call.return_value = None - client.delete_channel_group(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteChannelGroupRequest() +def test_create_reporting_data_annotation_rest_required_fields( + request_type=analytics_admin.CreateReportingDataAnnotationRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_set_automated_ga4_configuration_opt_out_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_reporting_data_annotation._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.set_automated_ga4_configuration_opt_out), "__call__" - ) as call: - call.return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() - client.set_automated_ga4_configuration_opt_out(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() + jsonified_request["parent"] = "parent_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_reporting_data_annotation._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" -# 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_automated_ga4_configuration_opt_out_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.fetch_automated_ga4_configuration_opt_out), "__call__" - ) as call: - call.return_value = ( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() - ) - client.fetch_automated_ga4_configuration_opt_out(request=None) + # Designate an appropriate value for the returned response. + return_value = resources.ReportingDataAnnotation() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = resources.ReportingDataAnnotation.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"} -# 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_big_query_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.create_reporting_data_annotation(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_big_query_link), "__call__" - ) as call: - call.return_value = resources.BigQueryLink() - client.create_big_query_link(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateBigQueryLinkRequest() - assert args[0] == request_msg +def test_create_reporting_data_annotation_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = ( + transport.create_reporting_data_annotation._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "reportingDataAnnotation", + ) + ) + ) -# 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_big_query_link_empty_call_grpc(): +def test_create_reporting_data_annotation_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_big_query_link), "__call__" - ) as call: - call.return_value = resources.BigQueryLink() - client.get_big_query_link(request=None) + # 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.ReportingDataAnnotation() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetBigQueryLinkRequest() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} - assert args[0] == request_msg + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + ) + 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.ReportingDataAnnotation.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"} -# 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_big_query_links_empty_call_grpc(): + client.create_reporting_data_annotation(**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=properties/*}/reportingDataAnnotations" + % client.transport._host, + args[1], + ) + + +def test_create_reporting_data_annotation_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_big_query_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListBigQueryLinksResponse() - client.list_big_query_links(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_reporting_data_annotation( + analytics_admin.CreateReportingDataAnnotationRequest(), + parent="parent_value", + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListBigQueryLinksRequest() - assert args[0] == request_msg +def test_get_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_big_query_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.get_reporting_data_annotation + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_big_query_link), "__call__" - ) as call: - call.return_value = None - client.delete_big_query_link(request=None) + # 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_reporting_data_annotation + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteBigQueryLinkRequest() + request = {} + client.get_reporting_data_annotation(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.get_reporting_data_annotation(request) -# 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_big_query_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_big_query_link), "__call__" - ) as call: - call.return_value = resources.BigQueryLink() - client.update_big_query_link(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateBigQueryLinkRequest() +def test_get_reporting_data_annotation_rest_required_fields( + request_type=analytics_admin.GetReportingDataAnnotationRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_enhanced_measurement_settings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_reporting_data_annotation._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_enhanced_measurement_settings), "__call__" - ) as call: - call.return_value = resources.EnhancedMeasurementSettings() - client.get_enhanced_measurement_settings(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetEnhancedMeasurementSettingsRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_reporting_data_annotation._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" -# 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_enhanced_measurement_settings_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_enhanced_measurement_settings), "__call__" - ) as call: - call.return_value = resources.EnhancedMeasurementSettings() - client.update_enhanced_measurement_settings(request=None) + # Designate an appropriate value for the returned response. + return_value = resources.ReportingDataAnnotation() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateEnhancedMeasurementSettingsRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = resources.ReportingDataAnnotation.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"} -# 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_connected_site_tag_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.get_reporting_data_annotation(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_connected_site_tag), "__call__" - ) as call: - call.return_value = analytics_admin.CreateConnectedSiteTagResponse() - client.create_connected_site_tag(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateConnectedSiteTagRequest() - assert args[0] == request_msg +def test_get_reporting_data_annotation_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_reporting_data_annotation._get_unset_required_fields( + {} + ) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_connected_site_tag_empty_call_grpc(): +def test_get_reporting_data_annotation_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_connected_site_tag), "__call__" - ) as call: - call.return_value = None - client.delete_connected_site_tag(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteConnectedSiteTagRequest() - - assert args[0] == request_msg + # 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.ReportingDataAnnotation() + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/reportingDataAnnotations/sample2"} -# 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_connected_site_tags_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_connected_site_tags), "__call__" - ) as call: - call.return_value = analytics_admin.ListConnectedSiteTagsResponse() - client.list_connected_site_tags(request=None) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = resources.ReportingDataAnnotation.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"} - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListConnectedSiteTagsRequest() + client.get_reporting_data_annotation(**mock_args) - assert args[0] == request_msg + # 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=properties/*/reportingDataAnnotations/*}" + % client.transport._host, + args[1], + ) -# 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_connected_ga4_property_empty_call_grpc(): +def test_get_reporting_data_annotation_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.fetch_connected_ga4_property), "__call__" - ) as call: - call.return_value = analytics_admin.FetchConnectedGa4PropertyResponse() - client.fetch_connected_ga4_property(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_reporting_data_annotation( + analytics_admin.GetReportingDataAnnotationRequest(), + name="name_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.FetchConnectedGa4PropertyRequest() - assert args[0] == request_msg +def test_list_reporting_data_annotations_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_ad_sense_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.list_reporting_data_annotations + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_ad_sense_link), "__call__" - ) as call: - call.return_value = resources.AdSenseLink() - client.get_ad_sense_link(request=None) + # 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_reporting_data_annotations + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAdSenseLinkRequest() + request = {} + client.list_reporting_data_annotations(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.list_reporting_data_annotations(request) -# 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_ad_sense_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_ad_sense_link), "__call__" - ) as call: - call.return_value = resources.AdSenseLink() - client.create_ad_sense_link(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateAdSenseLinkRequest() +def test_list_reporting_data_annotations_rest_required_fields( + request_type=analytics_admin.ListReportingDataAnnotationsRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_ad_sense_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_reporting_data_annotations._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_ad_sense_link), "__call__" - ) as call: - call.return_value = None - client.delete_ad_sense_link(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteAdSenseLinkRequest() + jsonified_request["parent"] = "parent_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_reporting_data_annotations._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" -# 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_ad_sense_links_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_ad_sense_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListAdSenseLinksResponse() - client.list_ad_sense_links(request=None) + # Designate an appropriate value for the returned response. + return_value = analytics_admin.ListReportingDataAnnotationsResponse() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAdSenseLinksRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = analytics_admin.ListReportingDataAnnotationsResponse.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"} -# 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_event_create_rule_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.list_reporting_data_annotations(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_event_create_rule), "__call__" - ) as call: - call.return_value = event_create_and_edit.EventCreateRule() - client.get_event_create_rule(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetEventCreateRuleRequest() - assert args[0] == request_msg +def test_list_reporting_data_annotations_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_reporting_data_annotations._get_unset_required_fields( + {} + ) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -# 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_event_create_rules_empty_call_grpc(): +def test_list_reporting_data_annotations_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_event_create_rules), "__call__" - ) as call: - call.return_value = analytics_admin.ListEventCreateRulesResponse() - client.list_event_create_rules(request=None) + # 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 = analytics_admin.ListReportingDataAnnotationsResponse() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListEventCreateRulesRequest() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "properties/sample1"} - assert args[0] == request_msg + # 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 = analytics_admin.ListReportingDataAnnotationsResponse.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"} -# 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_event_create_rule_empty_call_grpc(): + client.list_reporting_data_annotations(**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=properties/*}/reportingDataAnnotations" + % client.transport._host, + args[1], + ) + + +def test_list_reporting_data_annotations_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_event_create_rule), "__call__" - ) as call: - call.return_value = event_create_and_edit.EventCreateRule() - client.create_event_create_rule(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateEventCreateRuleRequest() - - assert args[0] == request_msg + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_reporting_data_annotations( + analytics_admin.ListReportingDataAnnotationsRequest(), + parent="parent_value", + ) -# 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_event_create_rule_empty_call_grpc(): +def test_list_reporting_data_annotations_rest_pager(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_event_create_rule), "__call__" - ) as call: - call.return_value = event_create_and_edit.EventCreateRule() - client.update_event_create_rule(request=None) + # 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 = ( + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + next_page_token="abc", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[], + next_page_token="def", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + ], + next_page_token="ghi", + ), + analytics_admin.ListReportingDataAnnotationsResponse( + reporting_data_annotations=[ + resources.ReportingDataAnnotation(), + resources.ReportingDataAnnotation(), + ], + ), + ) + # Two responses for two calls + response = response + response - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateEventCreateRuleRequest() + # Wrap the values into proper Response objs + response = tuple( + analytics_admin.ListReportingDataAnnotationsResponse.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 - assert args[0] == request_msg + sample_request = {"parent": "properties/sample1"} + pager = client.list_reporting_data_annotations(request=sample_request) -# 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_event_create_rule_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, resources.ReportingDataAnnotation) for i in results) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_event_create_rule), "__call__" - ) as call: - call.return_value = None - client.delete_event_create_rule(request=None) + pages = list( + client.list_reporting_data_annotations(request=sample_request).pages + ) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteEventCreateRuleRequest() - assert args[0] == request_msg +def test_update_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_event_edit_rule_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.update_reporting_data_annotation + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_event_edit_rule), "__call__" - ) as call: - call.return_value = event_create_and_edit.EventEditRule() - client.get_event_edit_rule(request=None) + # 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_reporting_data_annotation + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetEventEditRuleRequest() + request = {} + client.update_reporting_data_annotation(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.update_reporting_data_annotation(request) -# 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_event_edit_rules_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + # 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_reporting_data_annotation_rest_required_fields( + request_type=analytics_admin.UpdateReportingDataAnnotationRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport + + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_event_edit_rules), "__call__" - ) as call: - call.return_value = analytics_admin.ListEventEditRulesResponse() - client.list_event_edit_rules(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListEventEditRulesRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_reporting_data_annotation._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_reporting_data_annotation._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 -# 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_event_edit_rule_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_event_edit_rule), "__call__" - ) as call: - call.return_value = event_create_and_edit.EventEditRule() - client.create_event_edit_rule(request=None) + # Designate an appropriate value for the returned response. + return_value = resources.ReportingDataAnnotation() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateEventEditRuleRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = resources.ReportingDataAnnotation.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"} -# 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_event_edit_rule_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.update_reporting_data_annotation(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_event_edit_rule), "__call__" - ) as call: - call.return_value = event_create_and_edit.EventEditRule() - client.update_event_edit_rule(request=None) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateEventEditRuleRequest() - assert args[0] == request_msg +def test_update_reporting_data_annotation_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = ( + transport.update_reporting_data_annotation._get_unset_required_fields({}) + ) + assert set(unset_fields) == ( + set(("updateMask",)) & set(("reportingDataAnnotation",)) + ) -# 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_event_edit_rule_empty_call_grpc(): + +def test_update_reporting_data_annotation_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_event_edit_rule), "__call__" - ) as call: - call.return_value = None - client.delete_event_edit_rule(request=None) + # 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.ReportingDataAnnotation() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteEventEditRuleRequest() + # get arguments that satisfy an http rule for this method + sample_request = { + "reporting_data_annotation": { + "name": "properties/sample1/reportingDataAnnotations/sample2" + } + } - assert args[0] == request_msg + # get truthy value for each flattened field + mock_args = dict( + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + 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 = resources.ReportingDataAnnotation.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.update_reporting_data_annotation(**mock_args) -# 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_reorder_event_edit_rules_empty_call_grpc(): + # 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/{reporting_data_annotation.name=properties/*/reportingDataAnnotations/*}" + % client.transport._host, + args[1], + ) + + +def test_update_reporting_data_annotation_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.reorder_event_edit_rules), "__call__" - ) as call: - call.return_value = None - client.reorder_event_edit_rules(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_reporting_data_annotation( + analytics_admin.UpdateReportingDataAnnotationRequest(), + reporting_data_annotation=resources.ReportingDataAnnotation( + annotation_date=date_pb2.Date(year=433) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ReorderEventEditRulesRequest() - assert args[0] == request_msg +def test_delete_reporting_data_annotation_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_data_redaction_settings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.delete_reporting_data_annotation + in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_data_redaction_settings), "__call__" - ) as call: - call.return_value = resources.DataRedactionSettings() - client.update_data_redaction_settings(request=None) + # 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_reporting_data_annotation + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDataRedactionSettingsRequest() + request = {} + client.delete_reporting_data_annotation(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.delete_reporting_data_annotation(request) -# 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_data_redaction_settings_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_data_redaction_settings), "__call__" - ) as call: - call.return_value = resources.DataRedactionSettings() - client.get_data_redaction_settings(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataRedactionSettingsRequest() +def test_delete_reporting_data_annotation_rest_required_fields( + request_type=analytics_admin.DeleteReportingDataAnnotationRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport - assert args[0] == request_msg + 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 -# 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_calculated_metric_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_reporting_data_annotation._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_calculated_metric), "__call__" - ) as call: - call.return_value = resources.CalculatedMetric() - client.get_calculated_metric(request=None) + # verify required fields with default values are now present - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetCalculatedMetricRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_reporting_data_annotation._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" -# 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_calculated_metric_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_calculated_metric), "__call__" - ) as call: - call.return_value = resources.CalculatedMetric() - client.create_calculated_metric(request=None) + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateCalculatedMetricRequest() + response_value = Response() + response_value.status_code = 200 + json_return_value = "" - assert args[0] == request_msg + 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_reporting_data_annotation(request) -# 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_calculated_metrics_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_calculated_metrics), "__call__" - ) as call: - call.return_value = analytics_admin.ListCalculatedMetricsResponse() - client.list_calculated_metrics(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListCalculatedMetricsRequest() +def test_delete_reporting_data_annotation_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - assert args[0] == request_msg + unset_fields = ( + transport.delete_reporting_data_annotation._get_unset_required_fields({}) + ) + assert set(unset_fields) == (set(()) & set(("name",))) -# 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_calculated_metric_empty_call_grpc(): +def test_delete_reporting_data_annotation_rest_flattened(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_calculated_metric), "__call__" - ) as call: - call.return_value = resources.CalculatedMetric() - client.update_calculated_metric(request=None) + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateCalculatedMetricRequest() + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/sample1/reportingDataAnnotations/sample2"} - assert args[0] == request_msg + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} -# 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_calculated_metric_empty_call_grpc(): + client.delete_reporting_data_annotation(**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=properties/*/reportingDataAnnotations/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_reporting_data_annotation_rest_flattened_error(transport: str = "rest"): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_calculated_metric), "__call__" - ) as call: - call.return_value = None - client.delete_calculated_metric(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_reporting_data_annotation( + analytics_admin.DeleteReportingDataAnnotationRequest(), + name="name_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteCalculatedMetricRequest() - assert args[0] == request_msg +def test_submit_user_deletion_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 = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# 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_rollup_property_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert ( + client._transport.submit_user_deletion in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_rollup_property), "__call__" - ) as call: - call.return_value = analytics_admin.CreateRollupPropertyResponse() - client.create_rollup_property(request=None) + # 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.submit_user_deletion + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateRollupPropertyRequest() + request = {} + client.submit_user_deletion(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.submit_user_deletion(request) -# 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_rollup_property_source_link_empty_call_grpc(): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + # 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_submit_user_deletion_rest_required_fields( + request_type=analytics_admin.SubmitUserDeletionRequest, +): + transport_class = transports.AnalyticsAdminServiceRestTransport + + 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) ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_rollup_property_source_link), "__call__" - ) as call: - call.return_value = resources.RollupPropertySourceLink() - client.get_rollup_property_source_link(request=None) + # verify fields with default values are dropped - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetRollupPropertySourceLinkRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).submit_user_deletion._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - assert args[0] == request_msg + # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).submit_user_deletion._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" -# 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_rollup_property_source_links_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_rollup_property_source_links), "__call__" - ) as call: - call.return_value = analytics_admin.ListRollupPropertySourceLinksResponse() - client.list_rollup_property_source_links(request=None) + # Designate an appropriate value for the returned response. + return_value = analytics_admin.SubmitUserDeletionResponse() + # 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 - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListRollupPropertySourceLinksRequest() + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = analytics_admin.SubmitUserDeletionResponse.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.submit_user_deletion(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_submit_user_deletion_rest_unset_required_fields(): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.submit_user_deletion._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_submit_user_deletion_rest_flattened(): + client = AnalyticsAdminServiceClient( + 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 = analytics_admin.SubmitUserDeletionResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "properties/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 = analytics_admin.SubmitUserDeletionResponse.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.submit_user_deletion(**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=properties/*}:submitUserDeletion" + % client.transport._host, + args[1], + ) + + +def test_submit_user_deletion_rest_flattened_error(transport: str = "rest"): + client = AnalyticsAdminServiceClient( + 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.submit_user_deletion( + analytics_admin.SubmitUserDeletionRequest(), + name="name_value", + ) + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.AnalyticsAdminServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.AnalyticsAdminServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = AnalyticsAdminServiceClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide an api_key and a transport instance. + transport = transports.AnalyticsAdminServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = AnalyticsAdminServiceClient( + 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 = AnalyticsAdminServiceClient( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.AnalyticsAdminServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = AnalyticsAdminServiceClient( + client_options={"scopes": ["1", "2"]}, + transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.AnalyticsAdminServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = AnalyticsAdminServiceClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.AnalyticsAdminServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.AnalyticsAdminServiceGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.AnalyticsAdminServiceGrpcTransport, + transports.AnalyticsAdminServiceGrpcAsyncIOTransport, + transports.AnalyticsAdminServiceRestTransport, + ], +) +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 = AnalyticsAdminServiceClient.get_transport_class("grpc")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "grpc" - assert args[0] == request_msg + +def test_initialize_client_w_grpc(): + client = AnalyticsAdminServiceClient( + 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_create_rollup_property_source_link_empty_call_grpc(): +def test_get_account_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_rollup_property_source_link), "__call__" - ) as call: - call.return_value = resources.RollupPropertySourceLink() - client.create_rollup_property_source_link(request=None) + with mock.patch.object(type(client.transport.get_account), "__call__") as call: + call.return_value = resources.Account() + client.get_account(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateRollupPropertySourceLinkRequest() + request_msg = analytics_admin.GetAccountRequest() 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_rollup_property_source_link_empty_call_grpc(): +def test_list_accounts_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_rollup_property_source_link), "__call__" - ) as call: - call.return_value = None - client.delete_rollup_property_source_link(request=None) + with mock.patch.object(type(client.transport.list_accounts), "__call__") as call: + call.return_value = analytics_admin.ListAccountsResponse() + client.list_accounts(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteRollupPropertySourceLinkRequest() + request_msg = analytics_admin.ListAccountsRequest() 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_provision_subproperty_empty_call_grpc(): +def test_delete_account_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.provision_subproperty), "__call__" - ) as call: - call.return_value = analytics_admin.ProvisionSubpropertyResponse() - client.provision_subproperty(request=None) + with mock.patch.object(type(client.transport.delete_account), "__call__") as call: + call.return_value = None + client.delete_account(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ProvisionSubpropertyRequest() + request_msg = analytics_admin.DeleteAccountRequest() 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_subproperty_event_filter_empty_call_grpc(): +def test_update_account_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_subproperty_event_filter), "__call__" - ) as call: - call.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() - client.create_subproperty_event_filter(request=None) + with mock.patch.object(type(client.transport.update_account), "__call__") as call: + call.return_value = resources.Account() + client.update_account(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateSubpropertyEventFilterRequest() + request_msg = analytics_admin.UpdateAccountRequest() 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_subproperty_event_filter_empty_call_grpc(): +def test_provision_account_ticket_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", @@ -88334,22 +88636,22 @@ def test_get_subproperty_event_filter_empty_call_grpc(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_subproperty_event_filter), "__call__" + type(client.transport.provision_account_ticket), "__call__" ) as call: - call.return_value = subproperty_event_filter.SubpropertyEventFilter() - client.get_subproperty_event_filter(request=None) + call.return_value = analytics_admin.ProvisionAccountTicketResponse() + client.provision_account_ticket(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetSubpropertyEventFilterRequest() + request_msg = analytics_admin.ProvisionAccountTicketRequest() 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_subproperty_event_filters_empty_call_grpc(): +def test_list_account_summaries_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", @@ -88357,4205 +88659,3528 @@ def test_list_subproperty_event_filters_empty_call_grpc(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_subproperty_event_filters), "__call__" + type(client.transport.list_account_summaries), "__call__" ) as call: - call.return_value = analytics_admin.ListSubpropertyEventFiltersResponse() - client.list_subproperty_event_filters(request=None) + call.return_value = analytics_admin.ListAccountSummariesResponse() + client.list_account_summaries(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListSubpropertyEventFiltersRequest() + request_msg = analytics_admin.ListAccountSummariesRequest() 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_subproperty_event_filter_empty_call_grpc(): +def test_get_property_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_subproperty_event_filter), "__call__" - ) as call: - call.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() - client.update_subproperty_event_filter(request=None) + with mock.patch.object(type(client.transport.get_property), "__call__") as call: + call.return_value = resources.Property() + client.get_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateSubpropertyEventFilterRequest() + request_msg = analytics_admin.GetPropertyRequest() 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_subproperty_event_filter_empty_call_grpc(): +def test_list_properties_empty_call_grpc(): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_subproperty_event_filter), "__call__" - ) as call: - call.return_value = None - client.delete_subproperty_event_filter(request=None) + with mock.patch.object(type(client.transport.list_properties), "__call__") as call: + call.return_value = analytics_admin.ListPropertiesResponse() + client.list_properties(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteSubpropertyEventFilterRequest() + request_msg = analytics_admin.ListPropertiesRequest() assert args[0] == request_msg -def test_transport_kind_grpc_asyncio(): - transport = AnalyticsAdminServiceAsyncClient.get_transport_class("grpc_asyncio")( - credentials=async_anonymous_credentials() +# 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_property_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) - assert transport.kind == "grpc_asyncio" + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_property), "__call__") as call: + call.return_value = resources.Property() + client.create_property(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreatePropertyRequest() -def test_initialize_client_w_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), transport="grpc_asyncio" - ) - assert client is not None + 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_account_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_property_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_account), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Account( - name="name_value", - display_name="display_name_value", - region_code="region_code_value", - deleted=True, - gmp_organization="gmp_organization_value", - ) - ) - await client.get_account(request=None) + with mock.patch.object(type(client.transport.delete_property), "__call__") as call: + call.return_value = resources.Property() + client.delete_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAccountRequest() + request_msg = analytics_admin.DeletePropertyRequest() 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_accounts_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_property_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_accounts), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListAccountsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_accounts(request=None) + with mock.patch.object(type(client.transport.update_property), "__call__") as call: + call.return_value = resources.Property() + client.update_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAccountsRequest() + request_msg = analytics_admin.UpdatePropertyRequest() 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_account_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_firebase_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_account), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_account(request=None) + with mock.patch.object( + type(client.transport.create_firebase_link), "__call__" + ) as call: + call.return_value = resources.FirebaseLink() + client.create_firebase_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteAccountRequest() + request_msg = analytics_admin.CreateFirebaseLinkRequest() 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_account_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_firebase_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_account), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Account( - name="name_value", - display_name="display_name_value", - region_code="region_code_value", - deleted=True, - gmp_organization="gmp_organization_value", - ) - ) - await client.update_account(request=None) + with mock.patch.object( + type(client.transport.delete_firebase_link), "__call__" + ) as call: + call.return_value = None + client.delete_firebase_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAccountRequest() + request_msg = analytics_admin.DeleteFirebaseLinkRequest() 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_provision_account_ticket_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_firebase_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.provision_account_ticket), "__call__" + type(client.transport.list_firebase_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ProvisionAccountTicketResponse( - account_ticket_id="account_ticket_id_value", - ) - ) - await client.provision_account_ticket(request=None) + call.return_value = analytics_admin.ListFirebaseLinksResponse() + client.list_firebase_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ProvisionAccountTicketRequest() + request_msg = analytics_admin.ListFirebaseLinksRequest() 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_account_summaries_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_global_site_tag_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_account_summaries), "__call__" + type(client.transport.get_global_site_tag), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListAccountSummariesResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_account_summaries(request=None) + call.return_value = resources.GlobalSiteTag() + client.get_global_site_tag(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAccountSummariesRequest() + request_msg = analytics_admin.GetGlobalSiteTagRequest() 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_property_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_google_ads_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_property), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Property( - name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", - ) - ) - await client.get_property(request=None) + with mock.patch.object( + type(client.transport.create_google_ads_link), "__call__" + ) as call: + call.return_value = resources.GoogleAdsLink() + client.create_google_ads_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetPropertyRequest() + request_msg = analytics_admin.CreateGoogleAdsLinkRequest() 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_properties_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_google_ads_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_properties), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListPropertiesResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_properties(request=None) + with mock.patch.object( + type(client.transport.update_google_ads_link), "__call__" + ) as call: + call.return_value = resources.GoogleAdsLink() + client.update_google_ads_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListPropertiesRequest() + request_msg = analytics_admin.UpdateGoogleAdsLinkRequest() 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_property_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_google_ads_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_property), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Property( - name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", - ) - ) - await client.create_property(request=None) + with mock.patch.object( + type(client.transport.delete_google_ads_link), "__call__" + ) as call: + call.return_value = None + client.delete_google_ads_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreatePropertyRequest() + request_msg = analytics_admin.DeleteGoogleAdsLinkRequest() 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_property_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_google_ads_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_property), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Property( - name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", - ) - ) - await client.delete_property(request=None) + with mock.patch.object( + type(client.transport.list_google_ads_links), "__call__" + ) as call: + call.return_value = analytics_admin.ListGoogleAdsLinksResponse() + client.list_google_ads_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeletePropertyRequest() + request_msg = analytics_admin.ListGoogleAdsLinksRequest() 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_property_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_data_sharing_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_property), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.Property( - name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", - ) - ) - await client.update_property(request=None) + with mock.patch.object( + type(client.transport.get_data_sharing_settings), "__call__" + ) as call: + call.return_value = resources.DataSharingSettings() + client.get_data_sharing_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdatePropertyRequest() + request_msg = analytics_admin.GetDataSharingSettingsRequest() 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_firebase_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_measurement_protocol_secret_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_firebase_link), "__call__" + type(client.transport.get_measurement_protocol_secret), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.FirebaseLink( - name="name_value", - project="project_value", - ) - ) - await client.create_firebase_link(request=None) + call.return_value = resources.MeasurementProtocolSecret() + client.get_measurement_protocol_secret(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateFirebaseLinkRequest() + request_msg = analytics_admin.GetMeasurementProtocolSecretRequest() 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_firebase_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_measurement_protocol_secrets_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_firebase_link), "__call__" + type(client.transport.list_measurement_protocol_secrets), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_firebase_link(request=None) + call.return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() + client.list_measurement_protocol_secrets(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteFirebaseLinkRequest() + request_msg = analytics_admin.ListMeasurementProtocolSecretsRequest() 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_firebase_links_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_measurement_protocol_secret_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_firebase_links), "__call__" + type(client.transport.create_measurement_protocol_secret), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListFirebaseLinksResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_firebase_links(request=None) + call.return_value = resources.MeasurementProtocolSecret() + client.create_measurement_protocol_secret(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListFirebaseLinksRequest() + request_msg = analytics_admin.CreateMeasurementProtocolSecretRequest() 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_global_site_tag_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_measurement_protocol_secret_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_global_site_tag), "__call__" + type(client.transport.delete_measurement_protocol_secret), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.GlobalSiteTag( - name="name_value", - snippet="snippet_value", - ) - ) - await client.get_global_site_tag(request=None) + call.return_value = None + client.delete_measurement_protocol_secret(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetGlobalSiteTagRequest() + request_msg = analytics_admin.DeleteMeasurementProtocolSecretRequest() 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_google_ads_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_measurement_protocol_secret_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_google_ads_link), "__call__" + type(client.transport.update_measurement_protocol_secret), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.GoogleAdsLink( - name="name_value", - customer_id="customer_id_value", - can_manage_clients=True, - creator_email_address="creator_email_address_value", - ) - ) - await client.create_google_ads_link(request=None) + call.return_value = resources.MeasurementProtocolSecret() + client.update_measurement_protocol_secret(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateGoogleAdsLinkRequest() + request_msg = analytics_admin.UpdateMeasurementProtocolSecretRequest() 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_google_ads_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_acknowledge_user_data_collection_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_google_ads_link), "__call__" + type(client.transport.acknowledge_user_data_collection), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.GoogleAdsLink( - name="name_value", - customer_id="customer_id_value", - can_manage_clients=True, - creator_email_address="creator_email_address_value", - ) - ) - await client.update_google_ads_link(request=None) + call.return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() + client.acknowledge_user_data_collection(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateGoogleAdsLinkRequest() + request_msg = analytics_admin.AcknowledgeUserDataCollectionRequest() 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_google_ads_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_sk_ad_network_conversion_value_schema_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_google_ads_link), "__call__" + type(client.transport.get_sk_ad_network_conversion_value_schema), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_google_ads_link(request=None) + call.return_value = resources.SKAdNetworkConversionValueSchema() + client.get_sk_ad_network_conversion_value_schema(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteGoogleAdsLinkRequest() + request_msg = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() 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_google_ads_links_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_sk_ad_network_conversion_value_schema_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_google_ads_links), "__call__" + type(client.transport.create_sk_ad_network_conversion_value_schema), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListGoogleAdsLinksResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_google_ads_links(request=None) + call.return_value = resources.SKAdNetworkConversionValueSchema() + client.create_sk_ad_network_conversion_value_schema(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListGoogleAdsLinksRequest() + request_msg = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() 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_data_sharing_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_sk_ad_network_conversion_value_schema_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_data_sharing_settings), "__call__" + type(client.transport.delete_sk_ad_network_conversion_value_schema), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataSharingSettings( - name="name_value", - sharing_with_google_support_enabled=True, - sharing_with_google_assigned_sales_enabled=True, - sharing_with_google_any_sales_enabled=True, - sharing_with_google_products_enabled=True, - sharing_with_others_enabled=True, - ) - ) - await client.get_data_sharing_settings(request=None) + call.return_value = None + client.delete_sk_ad_network_conversion_value_schema(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataSharingSettingsRequest() + request_msg = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() 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_measurement_protocol_secret_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_sk_ad_network_conversion_value_schema_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_measurement_protocol_secret), "__call__" + type(client.transport.update_sk_ad_network_conversion_value_schema), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.MeasurementProtocolSecret( - name="name_value", - display_name="display_name_value", - secret_value="secret_value_value", - ) - ) - await client.get_measurement_protocol_secret(request=None) + call.return_value = resources.SKAdNetworkConversionValueSchema() + client.update_sk_ad_network_conversion_value_schema(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetMeasurementProtocolSecretRequest() + request_msg = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() 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_measurement_protocol_secrets_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_sk_ad_network_conversion_value_schemas_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_measurement_protocol_secrets), "__call__" + type(client.transport.list_sk_ad_network_conversion_value_schemas), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListMeasurementProtocolSecretsResponse( - next_page_token="next_page_token_value", - ) + call.return_value = ( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() ) - await client.list_measurement_protocol_secrets(request=None) + client.list_sk_ad_network_conversion_value_schemas(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListMeasurementProtocolSecretsRequest() + request_msg = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() 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_measurement_protocol_secret_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_change_history_events_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_measurement_protocol_secret), "__call__" + type(client.transport.search_change_history_events), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.MeasurementProtocolSecret( - name="name_value", - display_name="display_name_value", - secret_value="secret_value_value", - ) - ) - await client.create_measurement_protocol_secret(request=None) + call.return_value = analytics_admin.SearchChangeHistoryEventsResponse() + client.search_change_history_events(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateMeasurementProtocolSecretRequest() + request_msg = analytics_admin.SearchChangeHistoryEventsRequest() 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_measurement_protocol_secret_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_google_signals_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_measurement_protocol_secret), "__call__" + type(client.transport.get_google_signals_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_measurement_protocol_secret(request=None) + call.return_value = resources.GoogleSignalsSettings() + client.get_google_signals_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteMeasurementProtocolSecretRequest() + request_msg = analytics_admin.GetGoogleSignalsSettingsRequest() 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_measurement_protocol_secret_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_google_signals_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_measurement_protocol_secret), "__call__" + type(client.transport.update_google_signals_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.MeasurementProtocolSecret( - name="name_value", - display_name="display_name_value", - secret_value="secret_value_value", - ) - ) - await client.update_measurement_protocol_secret(request=None) + call.return_value = resources.GoogleSignalsSettings() + client.update_google_signals_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateMeasurementProtocolSecretRequest() + request_msg = analytics_admin.UpdateGoogleSignalsSettingsRequest() 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_acknowledge_user_data_collection_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_conversion_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.acknowledge_user_data_collection), "__call__" + type(client.transport.create_conversion_event), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.AcknowledgeUserDataCollectionResponse() - ) - await client.acknowledge_user_data_collection(request=None) + call.return_value = resources.ConversionEvent() + client.create_conversion_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.AcknowledgeUserDataCollectionRequest() + request_msg = analytics_admin.CreateConversionEventRequest() 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_conversion_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_sk_ad_network_conversion_value_schema), "__call__" + type(client.transport.update_conversion_event), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.SKAdNetworkConversionValueSchema( - name="name_value", - apply_conversion_values=True, - ) - ) - await client.get_sk_ad_network_conversion_value_schema(request=None) + call.return_value = resources.ConversionEvent() + client.update_conversion_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() + request_msg = analytics_admin.UpdateConversionEventRequest() 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_conversion_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_sk_ad_network_conversion_value_schema), "__call__" + type(client.transport.get_conversion_event), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.SKAdNetworkConversionValueSchema( - name="name_value", - apply_conversion_values=True, - ) - ) - await client.create_sk_ad_network_conversion_value_schema(request=None) + call.return_value = resources.ConversionEvent() + client.get_conversion_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() + request_msg = analytics_admin.GetConversionEventRequest() 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_conversion_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_sk_ad_network_conversion_value_schema), "__call__" + type(client.transport.delete_conversion_event), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_sk_ad_network_conversion_value_schema(request=None) + call.return_value = None + client.delete_conversion_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() + request_msg = analytics_admin.DeleteConversionEventRequest() 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_conversion_events_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_sk_ad_network_conversion_value_schema), "__call__" + type(client.transport.list_conversion_events), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.SKAdNetworkConversionValueSchema( - name="name_value", - apply_conversion_values=True, - ) - ) - await client.update_sk_ad_network_conversion_value_schema(request=None) + call.return_value = analytics_admin.ListConversionEventsResponse() + client.list_conversion_events(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() + request_msg = analytics_admin.ListConversionEventsRequest() 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_sk_ad_network_conversion_value_schemas_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_key_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_sk_ad_network_conversion_value_schemas), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_sk_ad_network_conversion_value_schemas(request=None) + with mock.patch.object(type(client.transport.create_key_event), "__call__") as call: + call.return_value = resources.KeyEvent() + client.create_key_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() + request_msg = analytics_admin.CreateKeyEventRequest() 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_search_change_history_events_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_key_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.search_change_history_events), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.SearchChangeHistoryEventsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.search_change_history_events(request=None) + with mock.patch.object(type(client.transport.update_key_event), "__call__") as call: + call.return_value = resources.KeyEvent() + client.update_key_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.SearchChangeHistoryEventsRequest() + request_msg = analytics_admin.UpdateKeyEventRequest() 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_google_signals_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_key_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_google_signals_settings), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.GoogleSignalsSettings( - name="name_value", - state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, - consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, - ) - ) - await client.get_google_signals_settings(request=None) + with mock.patch.object(type(client.transport.get_key_event), "__call__") as call: + call.return_value = resources.KeyEvent() + client.get_key_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetGoogleSignalsSettingsRequest() + request_msg = analytics_admin.GetKeyEventRequest() 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_google_signals_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_key_event_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_google_signals_settings), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.GoogleSignalsSettings( - name="name_value", - state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, - consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, - ) - ) - await client.update_google_signals_settings(request=None) + with mock.patch.object(type(client.transport.delete_key_event), "__call__") as call: + call.return_value = None + client.delete_key_event(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateGoogleSignalsSettingsRequest() + request_msg = analytics_admin.DeleteKeyEventRequest() 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_conversion_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_key_events_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_conversion_event), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.ConversionEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, - ) - ) - await client.create_conversion_event(request=None) + with mock.patch.object(type(client.transport.list_key_events), "__call__") as call: + call.return_value = analytics_admin.ListKeyEventsResponse() + client.list_key_events(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateConversionEventRequest() + request_msg = analytics_admin.ListKeyEventsRequest() 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_conversion_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_display_video360_advertiser_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_conversion_event), "__call__" + type(client.transport.get_display_video360_advertiser_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.ConversionEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, - ) - ) - await client.update_conversion_event(request=None) + call.return_value = resources.DisplayVideo360AdvertiserLink() + client.get_display_video360_advertiser_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateConversionEventRequest() + request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() 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_conversion_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_display_video360_advertiser_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_conversion_event), "__call__" + type(client.transport.list_display_video360_advertiser_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.ConversionEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, - ) - ) - await client.get_conversion_event(request=None) + call.return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() + client.list_display_video360_advertiser_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetConversionEventRequest() + request_msg = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() 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_conversion_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_display_video360_advertiser_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_conversion_event), "__call__" + type(client.transport.create_display_video360_advertiser_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_conversion_event(request=None) + call.return_value = resources.DisplayVideo360AdvertiserLink() + client.create_display_video360_advertiser_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteConversionEventRequest() + request_msg = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() 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_conversion_events_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_display_video360_advertiser_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_conversion_events), "__call__" + type(client.transport.delete_display_video360_advertiser_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListConversionEventsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_conversion_events(request=None) + call.return_value = None + client.delete_display_video360_advertiser_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListConversionEventsRequest() + request_msg = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() 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_key_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_display_video360_advertiser_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_key_event), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.KeyEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, - ) - ) - await client.create_key_event(request=None) + with mock.patch.object( + type(client.transport.update_display_video360_advertiser_link), "__call__" + ) as call: + call.return_value = resources.DisplayVideo360AdvertiserLink() + client.update_display_video360_advertiser_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateKeyEventRequest() + request_msg = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() 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_key_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_display_video360_advertiser_link_proposal_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_key_event), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.KeyEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, - ) - ) - await client.update_key_event(request=None) + with mock.patch.object( + type(client.transport.get_display_video360_advertiser_link_proposal), "__call__" + ) as call: + call.return_value = resources.DisplayVideo360AdvertiserLinkProposal() + client.get_display_video360_advertiser_link_proposal(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateKeyEventRequest() + request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() 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_key_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_display_video360_advertiser_link_proposals_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_key_event), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.KeyEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, - ) + with mock.patch.object( + type(client.transport.list_display_video360_advertiser_link_proposals), + "__call__", + ) as call: + call.return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() ) - await client.get_key_event(request=None) + client.list_display_video360_advertiser_link_proposals(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetKeyEventRequest() + request_msg = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() + ) 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_key_event_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_display_video360_advertiser_link_proposal_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_key_event), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_key_event(request=None) + with mock.patch.object( + type(client.transport.create_display_video360_advertiser_link_proposal), + "__call__", + ) as call: + call.return_value = resources.DisplayVideo360AdvertiserLinkProposal() + client.create_display_video360_advertiser_link_proposal(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteKeyEventRequest() + request_msg = ( + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() + ) 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_key_events_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_display_video360_advertiser_link_proposal_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_key_events), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListKeyEventsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_key_events(request=None) + with mock.patch.object( + type(client.transport.delete_display_video360_advertiser_link_proposal), + "__call__", + ) as call: + call.return_value = None + client.delete_display_video360_advertiser_link_proposal(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListKeyEventsRequest() + request_msg = ( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() + ) 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_approve_display_video360_advertiser_link_proposal_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_display_video360_advertiser_link), "__call__" + type(client.transport.approve_display_video360_advertiser_link_proposal), + "__call__", ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DisplayVideo360AdvertiserLink( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) + call.return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() ) - await client.get_display_video360_advertiser_link(request=None) + client.approve_display_video360_advertiser_link_proposal(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() + request_msg = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() + ) 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_display_video360_advertiser_links_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_cancel_display_video360_advertiser_link_proposal_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_display_video360_advertiser_links), "__call__" + type(client.transport.cancel_display_video360_advertiser_link_proposal), + "__call__", ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_display_video360_advertiser_links(request=None) + call.return_value = resources.DisplayVideo360AdvertiserLinkProposal() + client.cancel_display_video360_advertiser_link_proposal(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() + request_msg = ( + analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() + ) 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_custom_dimension_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_display_video360_advertiser_link), "__call__" + type(client.transport.create_custom_dimension), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DisplayVideo360AdvertiserLink( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) - ) - await client.create_display_video360_advertiser_link(request=None) + call.return_value = resources.CustomDimension() + client.create_custom_dimension(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() + request_msg = analytics_admin.CreateCustomDimensionRequest() 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_custom_dimension_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_display_video360_advertiser_link), "__call__" + type(client.transport.update_custom_dimension), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_display_video360_advertiser_link(request=None) + call.return_value = resources.CustomDimension() + client.update_custom_dimension(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() + request_msg = analytics_admin.UpdateCustomDimensionRequest() 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_custom_dimensions_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_display_video360_advertiser_link), "__call__" + type(client.transport.list_custom_dimensions), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DisplayVideo360AdvertiserLink( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) - ) - await client.update_display_video360_advertiser_link(request=None) + call.return_value = analytics_admin.ListCustomDimensionsResponse() + client.list_custom_dimensions(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() + request_msg = analytics_admin.ListCustomDimensionsRequest() 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_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_archive_custom_dimension_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_display_video360_advertiser_link_proposal), "__call__" + type(client.transport.archive_custom_dimension), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DisplayVideo360AdvertiserLinkProposal( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - validation_email="validation_email_value", - ) - ) - await client.get_display_video360_advertiser_link_proposal(request=None) + call.return_value = None + client.archive_custom_dimension(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() + request_msg = analytics_admin.ArchiveCustomDimensionRequest() 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_display_video360_advertiser_link_proposals_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) - +def test_get_custom_dimension_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_display_video360_advertiser_link_proposals), - "__call__", + type(client.transport.get_custom_dimension), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_display_video360_advertiser_link_proposals(request=None) + call.return_value = resources.CustomDimension() + client.get_custom_dimension(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() - ) + request_msg = analytics_admin.GetCustomDimensionRequest() 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_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_custom_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_display_video360_advertiser_link_proposal), - "__call__", + type(client.transport.create_custom_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DisplayVideo360AdvertiserLinkProposal( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - validation_email="validation_email_value", - ) - ) - await client.create_display_video360_advertiser_link_proposal(request=None) + call.return_value = resources.CustomMetric() + client.create_custom_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() - ) + request_msg = analytics_admin.CreateCustomMetricRequest() 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_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_custom_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_display_video360_advertiser_link_proposal), - "__call__", + type(client.transport.update_custom_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_display_video360_advertiser_link_proposal(request=None) + call.return_value = resources.CustomMetric() + client.update_custom_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() - ) + request_msg = analytics_admin.UpdateCustomMetricRequest() 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_approve_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_custom_metrics_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.approve_display_video360_advertiser_link_proposal), - "__call__", + type(client.transport.list_custom_metrics), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() - ) - await client.approve_display_video360_advertiser_link_proposal(request=None) + call.return_value = analytics_admin.ListCustomMetricsResponse() + client.list_custom_metrics(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() - ) + request_msg = analytics_admin.ListCustomMetricsRequest() 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_cancel_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_archive_custom_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.cancel_display_video360_advertiser_link_proposal), - "__call__", + type(client.transport.archive_custom_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DisplayVideo360AdvertiserLinkProposal( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - validation_email="validation_email_value", - ) - ) - await client.cancel_display_video360_advertiser_link_proposal(request=None) + call.return_value = None + client.archive_custom_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = ( - analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() - ) + request_msg = analytics_admin.ArchiveCustomMetricRequest() 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_custom_dimension_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_custom_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_custom_dimension), "__call__" + type(client.transport.get_custom_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CustomDimension( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - scope=resources.CustomDimension.DimensionScope.EVENT, - disallow_ads_personalization=True, - ) - ) - await client.create_custom_dimension(request=None) + call.return_value = resources.CustomMetric() + client.get_custom_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateCustomDimensionRequest() + request_msg = analytics_admin.GetCustomMetricRequest() 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_custom_dimension_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_data_retention_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_custom_dimension), "__call__" + type(client.transport.get_data_retention_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CustomDimension( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - scope=resources.CustomDimension.DimensionScope.EVENT, - disallow_ads_personalization=True, - ) - ) - await client.update_custom_dimension(request=None) + call.return_value = resources.DataRetentionSettings() + client.get_data_retention_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateCustomDimensionRequest() + request_msg = analytics_admin.GetDataRetentionSettingsRequest() 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_custom_dimensions_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_data_retention_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_custom_dimensions), "__call__" + type(client.transport.update_data_retention_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListCustomDimensionsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_custom_dimensions(request=None) + call.return_value = resources.DataRetentionSettings() + client.update_data_retention_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListCustomDimensionsRequest() + request_msg = analytics_admin.UpdateDataRetentionSettingsRequest() 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_archive_custom_dimension_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_data_stream_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.archive_custom_dimension), "__call__" + type(client.transport.create_data_stream), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.archive_custom_dimension(request=None) + call.return_value = resources.DataStream() + client.create_data_stream(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ArchiveCustomDimensionRequest() + request_msg = analytics_admin.CreateDataStreamRequest() 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_custom_dimension_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_data_stream_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_custom_dimension), "__call__" + type(client.transport.delete_data_stream), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CustomDimension( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - scope=resources.CustomDimension.DimensionScope.EVENT, - disallow_ads_personalization=True, - ) - ) - await client.get_custom_dimension(request=None) + call.return_value = None + client.delete_data_stream(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetCustomDimensionRequest() + request_msg = analytics_admin.DeleteDataStreamRequest() 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_custom_metric_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_data_stream_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_custom_metric), "__call__" + type(client.transport.update_data_stream), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CustomMetric( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, - scope=resources.CustomMetric.MetricScope.EVENT, - restricted_metric_type=[ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ], - ) - ) - await client.create_custom_metric(request=None) + call.return_value = resources.DataStream() + client.update_data_stream(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateCustomMetricRequest() + request_msg = analytics_admin.UpdateDataStreamRequest() 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_custom_metric_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_data_streams_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_custom_metric), "__call__" + type(client.transport.list_data_streams), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CustomMetric( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, - scope=resources.CustomMetric.MetricScope.EVENT, - restricted_metric_type=[ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ], - ) - ) - await client.update_custom_metric(request=None) + call.return_value = analytics_admin.ListDataStreamsResponse() + client.list_data_streams(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateCustomMetricRequest() + request_msg = analytics_admin.ListDataStreamsRequest() 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_custom_metrics_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_data_stream_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_custom_metrics), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListCustomMetricsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_custom_metrics(request=None) + with mock.patch.object(type(client.transport.get_data_stream), "__call__") as call: + call.return_value = resources.DataStream() + client.get_data_stream(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListCustomMetricsRequest() + request_msg = analytics_admin.GetDataStreamRequest() 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_archive_custom_metric_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_audience_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.archive_custom_metric), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.archive_custom_metric(request=None) + with mock.patch.object(type(client.transport.get_audience), "__call__") as call: + call.return_value = audience.Audience() + client.get_audience(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ArchiveCustomMetricRequest() + request_msg = analytics_admin.GetAudienceRequest() 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_custom_metric_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_audiences_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_custom_metric), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CustomMetric( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, - scope=resources.CustomMetric.MetricScope.EVENT, - restricted_metric_type=[ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ], - ) - ) - await client.get_custom_metric(request=None) + with mock.patch.object(type(client.transport.list_audiences), "__call__") as call: + call.return_value = analytics_admin.ListAudiencesResponse() + client.list_audiences(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetCustomMetricRequest() + request_msg = analytics_admin.ListAudiencesRequest() 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_data_retention_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_audience_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_data_retention_settings), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataRetentionSettings( - name="name_value", - event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - reset_user_data_on_new_activity=True, - ) - ) - await client.get_data_retention_settings(request=None) + with mock.patch.object(type(client.transport.create_audience), "__call__") as call: + call.return_value = gaa_audience.Audience() + client.create_audience(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataRetentionSettingsRequest() + request_msg = analytics_admin.CreateAudienceRequest() 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_data_retention_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_audience_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_data_retention_settings), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataRetentionSettings( - name="name_value", - event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - reset_user_data_on_new_activity=True, - ) - ) - await client.update_data_retention_settings(request=None) + with mock.patch.object(type(client.transport.update_audience), "__call__") as call: + call.return_value = gaa_audience.Audience() + client.update_audience(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDataRetentionSettingsRequest() + request_msg = analytics_admin.UpdateAudienceRequest() 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_data_stream_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_archive_audience_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_data_stream), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataStream( - name="name_value", - type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, - display_name="display_name_value", - ) - ) - await client.create_data_stream(request=None) + with mock.patch.object(type(client.transport.archive_audience), "__call__") as call: + call.return_value = None + client.archive_audience(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateDataStreamRequest() + request_msg = analytics_admin.ArchiveAudienceRequest() 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_data_stream_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_search_ads360_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_data_stream), "__call__" + type(client.transport.get_search_ads360_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_data_stream(request=None) + call.return_value = resources.SearchAds360Link() + client.get_search_ads360_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteDataStreamRequest() + request_msg = analytics_admin.GetSearchAds360LinkRequest() 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_data_stream_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_search_ads360_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_data_stream), "__call__" + type(client.transport.list_search_ads360_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataStream( - name="name_value", - type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, - display_name="display_name_value", - ) - ) - await client.update_data_stream(request=None) + call.return_value = analytics_admin.ListSearchAds360LinksResponse() + client.list_search_ads360_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDataStreamRequest() + request_msg = analytics_admin.ListSearchAds360LinksRequest() 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_data_streams_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_search_ads360_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_data_streams), "__call__" + type(client.transport.create_search_ads360_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListDataStreamsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_data_streams(request=None) + call.return_value = resources.SearchAds360Link() + client.create_search_ads360_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListDataStreamsRequest() + request_msg = analytics_admin.CreateSearchAds360LinkRequest() 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_data_stream_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_search_ads360_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_data_stream), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataStream( - name="name_value", - type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, - display_name="display_name_value", - ) - ) - await client.get_data_stream(request=None) + with mock.patch.object( + type(client.transport.delete_search_ads360_link), "__call__" + ) as call: + call.return_value = None + client.delete_search_ads360_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataStreamRequest() + request_msg = analytics_admin.DeleteSearchAds360LinkRequest() 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_audience_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_search_ads360_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_audience), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - audience.Audience( - name="name_value", - display_name="display_name_value", - description="description_value", - membership_duration_days=2561, - ads_personalization_enabled=True, - exclusion_duration_mode=audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, - ) - ) - await client.get_audience(request=None) + with mock.patch.object( + type(client.transport.update_search_ads360_link), "__call__" + ) as call: + call.return_value = resources.SearchAds360Link() + client.update_search_ads360_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAudienceRequest() + request_msg = analytics_admin.UpdateSearchAds360LinkRequest() 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_audiences_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_attribution_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_audiences), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListAudiencesResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_audiences(request=None) + with mock.patch.object( + type(client.transport.get_attribution_settings), "__call__" + ) as call: + call.return_value = resources.AttributionSettings() + client.get_attribution_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAudiencesRequest() + request_msg = analytics_admin.GetAttributionSettingsRequest() 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_audience_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_attribution_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_audience), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_audience.Audience( - name="name_value", - display_name="display_name_value", - description="description_value", - membership_duration_days=2561, - ads_personalization_enabled=True, - exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, - ) - ) - await client.create_audience(request=None) + with mock.patch.object( + type(client.transport.update_attribution_settings), "__call__" + ) as call: + call.return_value = resources.AttributionSettings() + client.update_attribution_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateAudienceRequest() + request_msg = analytics_admin.UpdateAttributionSettingsRequest() 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_audience_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_run_access_report_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_audience), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_audience.Audience( - name="name_value", - display_name="display_name_value", - description="description_value", - membership_duration_days=2561, - ads_personalization_enabled=True, - exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, - ) - ) - await client.update_audience(request=None) + with mock.patch.object( + type(client.transport.run_access_report), "__call__" + ) as call: + call.return_value = analytics_admin.RunAccessReportResponse() + client.run_access_report(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAudienceRequest() + request_msg = analytics_admin.RunAccessReportRequest() 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_archive_audience_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_access_binding_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.archive_audience), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.archive_audience(request=None) + with mock.patch.object( + type(client.transport.create_access_binding), "__call__" + ) as call: + call.return_value = resources.AccessBinding() + client.create_access_binding(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ArchiveAudienceRequest() + request_msg = analytics_admin.CreateAccessBindingRequest() 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_search_ads360_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_access_binding_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_search_ads360_link), "__call__" + type(client.transport.get_access_binding), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.SearchAds360Link( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) - ) - await client.get_search_ads360_link(request=None) + call.return_value = resources.AccessBinding() + client.get_access_binding(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetSearchAds360LinkRequest() + request_msg = analytics_admin.GetAccessBindingRequest() 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_search_ads360_links_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_access_binding_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_search_ads360_links), "__call__" + type(client.transport.update_access_binding), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListSearchAds360LinksResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_search_ads360_links(request=None) + call.return_value = resources.AccessBinding() + client.update_access_binding(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListSearchAds360LinksRequest() + request_msg = analytics_admin.UpdateAccessBindingRequest() 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_search_ads360_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_access_binding_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_search_ads360_link), "__call__" + type(client.transport.delete_access_binding), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.SearchAds360Link( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) - ) - await client.create_search_ads360_link(request=None) + call.return_value = None + client.delete_access_binding(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateSearchAds360LinkRequest() + request_msg = analytics_admin.DeleteAccessBindingRequest() 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_search_ads360_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_access_bindings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_search_ads360_link), "__call__" + type(client.transport.list_access_bindings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_search_ads360_link(request=None) + call.return_value = analytics_admin.ListAccessBindingsResponse() + client.list_access_bindings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteSearchAds360LinkRequest() + request_msg = analytics_admin.ListAccessBindingsRequest() 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_search_ads360_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_batch_create_access_bindings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_search_ads360_link), "__call__" + type(client.transport.batch_create_access_bindings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.SearchAds360Link( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) - ) - await client.update_search_ads360_link(request=None) + call.return_value = analytics_admin.BatchCreateAccessBindingsResponse() + client.batch_create_access_bindings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateSearchAds360LinkRequest() + request_msg = analytics_admin.BatchCreateAccessBindingsRequest() 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_attribution_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_batch_get_access_bindings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_attribution_settings), "__call__" + type(client.transport.batch_get_access_bindings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AttributionSettings( - name="name_value", - acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, - other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, - reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, - ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, - ) - ) - await client.get_attribution_settings(request=None) + call.return_value = analytics_admin.BatchGetAccessBindingsResponse() + client.batch_get_access_bindings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAttributionSettingsRequest() + request_msg = analytics_admin.BatchGetAccessBindingsRequest() 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_attribution_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_batch_update_access_bindings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_attribution_settings), "__call__" + type(client.transport.batch_update_access_bindings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AttributionSettings( - name="name_value", - acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, - other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, - reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, - ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, - ) - ) - await client.update_attribution_settings(request=None) + call.return_value = analytics_admin.BatchUpdateAccessBindingsResponse() + client.batch_update_access_bindings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAttributionSettingsRequest() + request_msg = analytics_admin.BatchUpdateAccessBindingsRequest() 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_run_access_report_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_batch_delete_access_bindings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.run_access_report), "__call__" + type(client.transport.batch_delete_access_bindings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.RunAccessReportResponse( - row_count=992, - ) - ) - await client.run_access_report(request=None) + call.return_value = None + client.batch_delete_access_bindings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.RunAccessReportRequest() + request_msg = analytics_admin.BatchDeleteAccessBindingsRequest() 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_access_binding_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_expanded_data_set_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_access_binding), "__call__" + type(client.transport.get_expanded_data_set), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AccessBinding( - name="name_value", - roles=["roles_value"], - ) - ) - await client.create_access_binding(request=None) + call.return_value = expanded_data_set.ExpandedDataSet() + client.get_expanded_data_set(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateAccessBindingRequest() + request_msg = analytics_admin.GetExpandedDataSetRequest() 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_access_binding_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_expanded_data_sets_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_access_binding), "__call__" + type(client.transport.list_expanded_data_sets), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AccessBinding( - name="name_value", - roles=["roles_value"], - ) - ) - await client.get_access_binding(request=None) + call.return_value = analytics_admin.ListExpandedDataSetsResponse() + client.list_expanded_data_sets(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAccessBindingRequest() + request_msg = analytics_admin.ListExpandedDataSetsRequest() 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_access_binding_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_expanded_data_set_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_access_binding), "__call__" + type(client.transport.create_expanded_data_set), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AccessBinding( - name="name_value", - roles=["roles_value"], - ) - ) - await client.update_access_binding(request=None) + call.return_value = gaa_expanded_data_set.ExpandedDataSet() + client.create_expanded_data_set(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateAccessBindingRequest() + request_msg = analytics_admin.CreateExpandedDataSetRequest() 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_access_binding_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_expanded_data_set_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_access_binding), "__call__" + type(client.transport.update_expanded_data_set), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_access_binding(request=None) + call.return_value = gaa_expanded_data_set.ExpandedDataSet() + client.update_expanded_data_set(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteAccessBindingRequest() + request_msg = analytics_admin.UpdateExpandedDataSetRequest() 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_access_bindings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_expanded_data_set_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_access_bindings), "__call__" + type(client.transport.delete_expanded_data_set), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListAccessBindingsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_access_bindings(request=None) + call.return_value = None + client.delete_expanded_data_set(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAccessBindingsRequest() + request_msg = analytics_admin.DeleteExpandedDataSetRequest() 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_batch_create_access_bindings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_channel_group_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.batch_create_access_bindings), "__call__" + type(client.transport.get_channel_group), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.BatchCreateAccessBindingsResponse() - ) - await client.batch_create_access_bindings(request=None) + call.return_value = channel_group.ChannelGroup() + client.get_channel_group(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchCreateAccessBindingsRequest() + request_msg = analytics_admin.GetChannelGroupRequest() 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_batch_get_access_bindings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_channel_groups_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.batch_get_access_bindings), "__call__" + type(client.transport.list_channel_groups), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.BatchGetAccessBindingsResponse() - ) - await client.batch_get_access_bindings(request=None) + call.return_value = analytics_admin.ListChannelGroupsResponse() + client.list_channel_groups(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchGetAccessBindingsRequest() + request_msg = analytics_admin.ListChannelGroupsRequest() 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_batch_update_access_bindings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_channel_group_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.batch_update_access_bindings), "__call__" + type(client.transport.create_channel_group), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.BatchUpdateAccessBindingsResponse() - ) - await client.batch_update_access_bindings(request=None) + call.return_value = gaa_channel_group.ChannelGroup() + client.create_channel_group(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchUpdateAccessBindingsRequest() + request_msg = analytics_admin.CreateChannelGroupRequest() 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_batch_delete_access_bindings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_channel_group_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.batch_delete_access_bindings), "__call__" + type(client.transport.update_channel_group), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.batch_delete_access_bindings(request=None) + call.return_value = gaa_channel_group.ChannelGroup() + client.update_channel_group(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.BatchDeleteAccessBindingsRequest() + request_msg = analytics_admin.UpdateChannelGroupRequest() 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_expanded_data_set_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_channel_group_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_expanded_data_set), "__call__" + type(client.transport.delete_channel_group), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - expanded_data_set.ExpandedDataSet( - name="name_value", - display_name="display_name_value", - description="description_value", - dimension_names=["dimension_names_value"], - metric_names=["metric_names_value"], - ) - ) - await client.get_expanded_data_set(request=None) + call.return_value = None + client.delete_channel_group(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetExpandedDataSetRequest() + request_msg = analytics_admin.DeleteChannelGroupRequest() 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_expanded_data_sets_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_set_automated_ga4_configuration_opt_out_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_expanded_data_sets), "__call__" + type(client.transport.set_automated_ga4_configuration_opt_out), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListExpandedDataSetsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_expanded_data_sets(request=None) + call.return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + client.set_automated_ga4_configuration_opt_out(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListExpandedDataSetsRequest() + request_msg = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() 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_expanded_data_set_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_fetch_automated_ga4_configuration_opt_out_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_expanded_data_set), "__call__" + type(client.transport.fetch_automated_ga4_configuration_opt_out), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_expanded_data_set.ExpandedDataSet( - name="name_value", - display_name="display_name_value", - description="description_value", - dimension_names=["dimension_names_value"], - metric_names=["metric_names_value"], - ) + call.return_value = ( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() ) - await client.create_expanded_data_set(request=None) + client.fetch_automated_ga4_configuration_opt_out(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateExpandedDataSetRequest() + request_msg = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() 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_expanded_data_set_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_big_query_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_expanded_data_set), "__call__" + type(client.transport.create_big_query_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_expanded_data_set.ExpandedDataSet( - name="name_value", - display_name="display_name_value", - description="description_value", - dimension_names=["dimension_names_value"], - metric_names=["metric_names_value"], - ) - ) - await client.update_expanded_data_set(request=None) + call.return_value = resources.BigQueryLink() + client.create_big_query_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateExpandedDataSetRequest() + request_msg = analytics_admin.CreateBigQueryLinkRequest() 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_expanded_data_set_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_big_query_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_expanded_data_set), "__call__" + type(client.transport.get_big_query_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_expanded_data_set(request=None) + call.return_value = resources.BigQueryLink() + client.get_big_query_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteExpandedDataSetRequest() + request_msg = analytics_admin.GetBigQueryLinkRequest() 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_channel_group_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_big_query_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_channel_group), "__call__" + type(client.transport.list_big_query_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - channel_group.ChannelGroup( - name="name_value", - display_name="display_name_value", - description="description_value", - system_defined=True, - primary=True, - ) - ) - await client.get_channel_group(request=None) + call.return_value = analytics_admin.ListBigQueryLinksResponse() + client.list_big_query_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetChannelGroupRequest() + request_msg = analytics_admin.ListBigQueryLinksRequest() 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_channel_groups_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_big_query_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_channel_groups), "__call__" + type(client.transport.delete_big_query_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListChannelGroupsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_channel_groups(request=None) + call.return_value = None + client.delete_big_query_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListChannelGroupsRequest() + request_msg = analytics_admin.DeleteBigQueryLinkRequest() 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_channel_group_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_big_query_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_channel_group), "__call__" + type(client.transport.update_big_query_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_channel_group.ChannelGroup( - name="name_value", - display_name="display_name_value", - description="description_value", - system_defined=True, - primary=True, - ) - ) - await client.create_channel_group(request=None) + call.return_value = resources.BigQueryLink() + client.update_big_query_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateChannelGroupRequest() + request_msg = analytics_admin.UpdateBigQueryLinkRequest() 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_channel_group_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_enhanced_measurement_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_channel_group), "__call__" + type(client.transport.get_enhanced_measurement_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_channel_group.ChannelGroup( - name="name_value", - display_name="display_name_value", - description="description_value", - system_defined=True, - primary=True, - ) - ) - await client.update_channel_group(request=None) + call.return_value = resources.EnhancedMeasurementSettings() + client.get_enhanced_measurement_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateChannelGroupRequest() + request_msg = analytics_admin.GetEnhancedMeasurementSettingsRequest() 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_channel_group_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_enhanced_measurement_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_channel_group), "__call__" + type(client.transport.update_enhanced_measurement_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_channel_group(request=None) + call.return_value = resources.EnhancedMeasurementSettings() + client.update_enhanced_measurement_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteChannelGroupRequest() + request_msg = analytics_admin.UpdateEnhancedMeasurementSettingsRequest() 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_set_automated_ga4_configuration_opt_out_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_connected_site_tag_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.set_automated_ga4_configuration_opt_out), "__call__" + type(client.transport.create_connected_site_tag), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() - ) - await client.set_automated_ga4_configuration_opt_out(request=None) + call.return_value = analytics_admin.CreateConnectedSiteTagResponse() + client.create_connected_site_tag(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() + request_msg = analytics_admin.CreateConnectedSiteTagRequest() 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_automated_ga4_configuration_opt_out_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_connected_site_tag_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.fetch_automated_ga4_configuration_opt_out), "__call__" + type(client.transport.delete_connected_site_tag), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse( - opt_out=True, - ) - ) - await client.fetch_automated_ga4_configuration_opt_out(request=None) + call.return_value = None + client.delete_connected_site_tag(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() + request_msg = analytics_admin.DeleteConnectedSiteTagRequest() 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_big_query_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_connected_site_tags_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_big_query_link), "__call__" + type(client.transport.list_connected_site_tags), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.BigQueryLink( - name="name_value", - project="project_value", - daily_export_enabled=True, - streaming_export_enabled=True, - fresh_daily_export_enabled=True, - include_advertising_id=True, - export_streams=["export_streams_value"], - excluded_events=["excluded_events_value"], - dataset_location="dataset_location_value", - ) - ) - await client.create_big_query_link(request=None) + call.return_value = analytics_admin.ListConnectedSiteTagsResponse() + client.list_connected_site_tags(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateBigQueryLinkRequest() + request_msg = analytics_admin.ListConnectedSiteTagsRequest() 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_big_query_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_fetch_connected_ga4_property_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_big_query_link), "__call__" + type(client.transport.fetch_connected_ga4_property), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.BigQueryLink( - name="name_value", - project="project_value", - daily_export_enabled=True, - streaming_export_enabled=True, - fresh_daily_export_enabled=True, - include_advertising_id=True, - export_streams=["export_streams_value"], - excluded_events=["excluded_events_value"], - dataset_location="dataset_location_value", - ) - ) - await client.get_big_query_link(request=None) + call.return_value = analytics_admin.FetchConnectedGa4PropertyResponse() + client.fetch_connected_ga4_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetBigQueryLinkRequest() + request_msg = analytics_admin.FetchConnectedGa4PropertyRequest() 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_big_query_links_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_ad_sense_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_big_query_links), "__call__" + type(client.transport.get_ad_sense_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListBigQueryLinksResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_big_query_links(request=None) + call.return_value = resources.AdSenseLink() + client.get_ad_sense_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListBigQueryLinksRequest() + request_msg = analytics_admin.GetAdSenseLinkRequest() 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_big_query_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_ad_sense_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_big_query_link), "__call__" + type(client.transport.create_ad_sense_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_big_query_link(request=None) + call.return_value = resources.AdSenseLink() + client.create_ad_sense_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteBigQueryLinkRequest() + request_msg = analytics_admin.CreateAdSenseLinkRequest() 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_big_query_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_ad_sense_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_big_query_link), "__call__" + type(client.transport.delete_ad_sense_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.BigQueryLink( - name="name_value", - project="project_value", - daily_export_enabled=True, - streaming_export_enabled=True, - fresh_daily_export_enabled=True, - include_advertising_id=True, - export_streams=["export_streams_value"], - excluded_events=["excluded_events_value"], - dataset_location="dataset_location_value", - ) - ) - await client.update_big_query_link(request=None) + call.return_value = None + client.delete_ad_sense_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateBigQueryLinkRequest() + request_msg = analytics_admin.DeleteAdSenseLinkRequest() 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_enhanced_measurement_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_ad_sense_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_enhanced_measurement_settings), "__call__" + type(client.transport.list_ad_sense_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.EnhancedMeasurementSettings( - name="name_value", - stream_enabled=True, - scrolls_enabled=True, - outbound_clicks_enabled=True, - site_search_enabled=True, - video_engagement_enabled=True, - file_downloads_enabled=True, - page_changes_enabled=True, - form_interactions_enabled=True, - search_query_parameter="search_query_parameter_value", - uri_query_parameter="uri_query_parameter_value", - ) - ) - await client.get_enhanced_measurement_settings(request=None) + call.return_value = analytics_admin.ListAdSenseLinksResponse() + client.list_ad_sense_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetEnhancedMeasurementSettingsRequest() + request_msg = analytics_admin.ListAdSenseLinksRequest() 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_enhanced_measurement_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_event_create_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_enhanced_measurement_settings), "__call__" + type(client.transport.get_event_create_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.EnhancedMeasurementSettings( - name="name_value", - stream_enabled=True, - scrolls_enabled=True, - outbound_clicks_enabled=True, - site_search_enabled=True, - video_engagement_enabled=True, - file_downloads_enabled=True, - page_changes_enabled=True, - form_interactions_enabled=True, - search_query_parameter="search_query_parameter_value", - uri_query_parameter="uri_query_parameter_value", - ) - ) - await client.update_enhanced_measurement_settings(request=None) + call.return_value = event_create_and_edit.EventCreateRule() + client.get_event_create_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateEnhancedMeasurementSettingsRequest() + request_msg = analytics_admin.GetEventCreateRuleRequest() 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_connected_site_tag_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_event_create_rules_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_connected_site_tag), "__call__" + type(client.transport.list_event_create_rules), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.CreateConnectedSiteTagResponse() - ) - await client.create_connected_site_tag(request=None) + call.return_value = analytics_admin.ListEventCreateRulesResponse() + client.list_event_create_rules(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateConnectedSiteTagRequest() + request_msg = analytics_admin.ListEventCreateRulesRequest() 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_connected_site_tag_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_event_create_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_connected_site_tag), "__call__" + type(client.transport.create_event_create_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_connected_site_tag(request=None) + call.return_value = event_create_and_edit.EventCreateRule() + client.create_event_create_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteConnectedSiteTagRequest() + request_msg = analytics_admin.CreateEventCreateRuleRequest() 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_connected_site_tags_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_event_create_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_connected_site_tags), "__call__" + type(client.transport.update_event_create_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListConnectedSiteTagsResponse() - ) - await client.list_connected_site_tags(request=None) + call.return_value = event_create_and_edit.EventCreateRule() + client.update_event_create_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListConnectedSiteTagsRequest() + request_msg = analytics_admin.UpdateEventCreateRuleRequest() 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_connected_ga4_property_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_event_create_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.fetch_connected_ga4_property), "__call__" + type(client.transport.delete_event_create_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.FetchConnectedGa4PropertyResponse( - property="property_value", - ) - ) - await client.fetch_connected_ga4_property(request=None) + call.return_value = None + client.delete_event_create_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.FetchConnectedGa4PropertyRequest() + request_msg = analytics_admin.DeleteEventCreateRuleRequest() 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_ad_sense_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_event_edit_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_ad_sense_link), "__call__" + type(client.transport.get_event_edit_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AdSenseLink( - name="name_value", - ad_client_code="ad_client_code_value", - ) - ) - await client.get_ad_sense_link(request=None) + call.return_value = event_create_and_edit.EventEditRule() + client.get_event_edit_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetAdSenseLinkRequest() + request_msg = analytics_admin.GetEventEditRuleRequest() 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_ad_sense_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_event_edit_rules_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_ad_sense_link), "__call__" + type(client.transport.list_event_edit_rules), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.AdSenseLink( - name="name_value", - ad_client_code="ad_client_code_value", - ) - ) - await client.create_ad_sense_link(request=None) + call.return_value = analytics_admin.ListEventEditRulesResponse() + client.list_event_edit_rules(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateAdSenseLinkRequest() + request_msg = analytics_admin.ListEventEditRulesRequest() 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_ad_sense_link_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_event_edit_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_ad_sense_link), "__call__" + type(client.transport.create_event_edit_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_ad_sense_link(request=None) + call.return_value = event_create_and_edit.EventEditRule() + client.create_event_edit_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteAdSenseLinkRequest() + request_msg = analytics_admin.CreateEventEditRuleRequest() 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_ad_sense_links_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_event_edit_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_ad_sense_links), "__call__" + type(client.transport.update_event_edit_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListAdSenseLinksResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_ad_sense_links(request=None) + call.return_value = event_create_and_edit.EventEditRule() + client.update_event_edit_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListAdSenseLinksRequest() + request_msg = analytics_admin.UpdateEventEditRuleRequest() 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_event_create_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_event_edit_rule_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_event_create_rule), "__call__" + type(client.transport.delete_event_edit_rule), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - event_create_and_edit.EventCreateRule( - name="name_value", - destination_event="destination_event_value", - source_copy_parameters=True, - ) - ) - await client.get_event_create_rule(request=None) + call.return_value = None + client.delete_event_edit_rule(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetEventCreateRuleRequest() + request_msg = analytics_admin.DeleteEventEditRuleRequest() 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_event_create_rules_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_reorder_event_edit_rules_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_event_create_rules), "__call__" + type(client.transport.reorder_event_edit_rules), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListEventCreateRulesResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_event_create_rules(request=None) + call.return_value = None + client.reorder_event_edit_rules(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListEventCreateRulesRequest() + request_msg = analytics_admin.ReorderEventEditRulesRequest() 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_event_create_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_data_redaction_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_event_create_rule), "__call__" + type(client.transport.update_data_redaction_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - event_create_and_edit.EventCreateRule( - name="name_value", - destination_event="destination_event_value", - source_copy_parameters=True, - ) - ) - await client.create_event_create_rule(request=None) + call.return_value = resources.DataRedactionSettings() + client.update_data_redaction_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateEventCreateRuleRequest() + request_msg = analytics_admin.UpdateDataRedactionSettingsRequest() 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_event_create_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_data_redaction_settings_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_event_create_rule), "__call__" + type(client.transport.get_data_redaction_settings), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - event_create_and_edit.EventCreateRule( - name="name_value", - destination_event="destination_event_value", - source_copy_parameters=True, - ) - ) - await client.update_event_create_rule(request=None) + call.return_value = resources.DataRedactionSettings() + client.get_data_redaction_settings(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateEventCreateRuleRequest() + request_msg = analytics_admin.GetDataRedactionSettingsRequest() 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_event_create_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_calculated_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_event_create_rule), "__call__" + type(client.transport.get_calculated_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_event_create_rule(request=None) + call.return_value = resources.CalculatedMetric() + client.get_calculated_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteEventCreateRuleRequest() + request_msg = analytics_admin.GetCalculatedMetricRequest() 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_event_edit_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_calculated_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_event_edit_rule), "__call__" + type(client.transport.create_calculated_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - event_create_and_edit.EventEditRule( - name="name_value", - display_name="display_name_value", - processing_order=1720, - ) - ) - await client.get_event_edit_rule(request=None) + call.return_value = resources.CalculatedMetric() + client.create_calculated_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetEventEditRuleRequest() + request_msg = analytics_admin.CreateCalculatedMetricRequest() 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_event_edit_rules_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_calculated_metrics_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_event_edit_rules), "__call__" + type(client.transport.list_calculated_metrics), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListEventEditRulesResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_event_edit_rules(request=None) + call.return_value = analytics_admin.ListCalculatedMetricsResponse() + client.list_calculated_metrics(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListEventEditRulesRequest() + request_msg = analytics_admin.ListCalculatedMetricsRequest() 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_event_edit_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_update_calculated_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_event_edit_rule), "__call__" + type(client.transport.update_calculated_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - event_create_and_edit.EventEditRule( - name="name_value", - display_name="display_name_value", - processing_order=1720, - ) - ) - await client.create_event_edit_rule(request=None) + call.return_value = resources.CalculatedMetric() + client.update_calculated_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateEventEditRuleRequest() + request_msg = analytics_admin.UpdateCalculatedMetricRequest() 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_event_edit_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_calculated_metric_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_event_edit_rule), "__call__" + type(client.transport.delete_calculated_metric), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - event_create_and_edit.EventEditRule( - name="name_value", - display_name="display_name_value", - processing_order=1720, - ) - ) - await client.update_event_edit_rule(request=None) + call.return_value = None + client.delete_calculated_metric(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateEventEditRuleRequest() + request_msg = analytics_admin.DeleteCalculatedMetricRequest() 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_event_edit_rule_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_rollup_property_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_event_edit_rule), "__call__" + type(client.transport.create_rollup_property), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_event_edit_rule(request=None) + call.return_value = analytics_admin.CreateRollupPropertyResponse() + client.create_rollup_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteEventEditRuleRequest() + request_msg = analytics_admin.CreateRollupPropertyRequest() 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_reorder_event_edit_rules_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_get_rollup_property_source_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.reorder_event_edit_rules), "__call__" + type(client.transport.get_rollup_property_source_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.reorder_event_edit_rules(request=None) + call.return_value = resources.RollupPropertySourceLink() + client.get_rollup_property_source_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ReorderEventEditRulesRequest() + request_msg = analytics_admin.GetRollupPropertySourceLinkRequest() 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_data_redaction_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_list_rollup_property_source_links_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_data_redaction_settings), "__call__" + type(client.transport.list_rollup_property_source_links), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataRedactionSettings( - name="name_value", - email_redaction_enabled=True, - query_parameter_redaction_enabled=True, - query_parameter_keys=["query_parameter_keys_value"], - ) - ) - await client.update_data_redaction_settings(request=None) + call.return_value = analytics_admin.ListRollupPropertySourceLinksResponse() + client.list_rollup_property_source_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateDataRedactionSettingsRequest() + request_msg = analytics_admin.ListRollupPropertySourceLinksRequest() 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_data_redaction_settings_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_rollup_property_source_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_data_redaction_settings), "__call__" + type(client.transport.create_rollup_property_source_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.DataRedactionSettings( - name="name_value", - email_redaction_enabled=True, - query_parameter_redaction_enabled=True, - query_parameter_keys=["query_parameter_keys_value"], - ) - ) - await client.get_data_redaction_settings(request=None) + call.return_value = resources.RollupPropertySourceLink() + client.create_rollup_property_source_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetDataRedactionSettingsRequest() + request_msg = analytics_admin.CreateRollupPropertySourceLinkRequest() 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_calculated_metric_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_delete_rollup_property_source_link_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_calculated_metric), "__call__" + type(client.transport.delete_rollup_property_source_link), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CalculatedMetric( - name="name_value", - description="description_value", - display_name="display_name_value", - calculated_metric_id="calculated_metric_id_value", - metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, - restricted_metric_type=[ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ], - formula="formula_value", - invalid_metric_reference=True, - ) - ) - await client.get_calculated_metric(request=None) + call.return_value = None + client.delete_rollup_property_source_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetCalculatedMetricRequest() + request_msg = analytics_admin.DeleteRollupPropertySourceLinkRequest() 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_calculated_metric_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_provision_subproperty_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_calculated_metric), "__call__" + type(client.transport.provision_subproperty), "__call__" ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CalculatedMetric( - name="name_value", - description="description_value", - display_name="display_name_value", - calculated_metric_id="calculated_metric_id_value", - metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, - restricted_metric_type=[ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ], - formula="formula_value", - invalid_metric_reference=True, - ) - ) - await client.create_calculated_metric(request=None) + call.return_value = analytics_admin.ProvisionSubpropertyResponse() + client.provision_subproperty(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateCalculatedMetricRequest() + request_msg = analytics_admin.ProvisionSubpropertyRequest() 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_calculated_metrics_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_create_subproperty_event_filter_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_calculated_metrics), "__call__" + type(client.transport.create_subproperty_event_filter), "__call__" + ) as call: + call.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + client.create_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateSubpropertyEventFilterRequest() + + 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_subproperty_event_filter_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_subproperty_event_filter), "__call__" + ) as call: + call.return_value = subproperty_event_filter.SubpropertyEventFilter() + client.get_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetSubpropertyEventFilterRequest() + + 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_subproperty_event_filters_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_subproperty_event_filters), "__call__" + ) as call: + call.return_value = analytics_admin.ListSubpropertyEventFiltersResponse() + client.list_subproperty_event_filters(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListSubpropertyEventFiltersRequest() + + 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_subproperty_event_filter_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_subproperty_event_filter), "__call__" + ) as call: + call.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + client.update_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateSubpropertyEventFilterRequest() + + 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_subproperty_event_filter_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_subproperty_event_filter), "__call__" + ) as call: + call.return_value = None + client.delete_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteSubpropertyEventFilterRequest() + + 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_reporting_data_annotation_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + call.return_value = resources.ReportingDataAnnotation() + client.create_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateReportingDataAnnotationRequest() + + 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_reporting_data_annotation_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + call.return_value = resources.ReportingDataAnnotation() + client.get_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetReportingDataAnnotationRequest() + + 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_reporting_data_annotations_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + call.return_value = analytics_admin.ListReportingDataAnnotationsResponse() + client.list_reporting_data_annotations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListReportingDataAnnotationsRequest() + + 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_reporting_data_annotation_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + call.return_value = resources.ReportingDataAnnotation() + client.update_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateReportingDataAnnotationRequest() + + 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_reporting_data_annotation_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + call.return_value = None + client.delete_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteReportingDataAnnotationRequest() + + 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_submit_user_deletion_empty_call_grpc(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" ) as call: + call.return_value = analytics_admin.SubmitUserDeletionResponse() + client.submit_user_deletion(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.SubmitUserDeletionRequest() + + assert args[0] == request_msg + + +def test_transport_kind_grpc_asyncio(): + transport = AnalyticsAdminServiceAsyncClient.get_transport_class("grpc_asyncio")( + credentials=async_anonymous_credentials() + ) + assert transport.kind == "grpc_asyncio" + + +def test_initialize_client_w_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + 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_get_account_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_account), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListCalculatedMetricsResponse( + resources.Account( + name="name_value", + display_name="display_name_value", + region_code="region_code_value", + deleted=True, + gmp_organization="gmp_organization_value", + ) + ) + await client.get_account(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetAccountRequest() + + 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_accounts_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_accounts), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListAccountsResponse( next_page_token="next_page_token_value", ) ) - await client.list_calculated_metrics(request=None) + await client.list_accounts(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListCalculatedMetricsRequest() + request_msg = analytics_admin.ListAccountsRequest() assert args[0] == request_msg @@ -92563,37 +92188,53 @@ async def test_list_calculated_metrics_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_calculated_metric_empty_call_grpc_asyncio(): +async def test_delete_account_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_calculated_metric), "__call__" - ) as call: + with mock.patch.object(type(client.transport.delete_account), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_account(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteAccountRequest() + + 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_account_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_account), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.CalculatedMetric( + resources.Account( name="name_value", - description="description_value", display_name="display_name_value", - calculated_metric_id="calculated_metric_id_value", - metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, - restricted_metric_type=[ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ], - formula="formula_value", - invalid_metric_reference=True, + region_code="region_code_value", + deleted=True, + gmp_organization="gmp_organization_value", ) ) - await client.update_calculated_metric(request=None) + await client.update_account(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateCalculatedMetricRequest() + request_msg = analytics_admin.UpdateAccountRequest() assert args[0] == request_msg @@ -92601,7 +92242,7 @@ async def test_update_calculated_metric_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_calculated_metric_empty_call_grpc_asyncio(): +async def test_provision_account_ticket_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -92609,16 +92250,20 @@ async def test_delete_calculated_metric_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_calculated_metric), "__call__" + type(client.transport.provision_account_ticket), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_calculated_metric(request=None) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ProvisionAccountTicketResponse( + account_ticket_id="account_ticket_id_value", + ) + ) + await client.provision_account_ticket(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteCalculatedMetricRequest() + request_msg = analytics_admin.ProvisionAccountTicketRequest() assert args[0] == request_msg @@ -92626,7 +92271,7 @@ async def test_delete_calculated_metric_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_rollup_property_empty_call_grpc_asyncio(): +async def test_list_account_summaries_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -92634,18 +92279,20 @@ async def test_create_rollup_property_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_rollup_property), "__call__" + type(client.transport.list_account_summaries), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.CreateRollupPropertyResponse() + analytics_admin.ListAccountSummariesResponse( + next_page_token="next_page_token_value", + ) ) - await client.create_rollup_property(request=None) + await client.list_account_summaries(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateRollupPropertyRequest() + request_msg = analytics_admin.ListAccountSummariesRequest() assert args[0] == request_msg @@ -92653,29 +92300,34 @@ async def test_create_rollup_property_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_get_rollup_property_source_link_empty_call_grpc_asyncio(): +async def test_get_property_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_rollup_property_source_link), "__call__" - ) as call: + with mock.patch.object(type(client.transport.get_property), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.RollupPropertySourceLink( + resources.Property( name="name_value", - source_property="source_property_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_value", ) ) - await client.get_rollup_property_source_link(request=None) + await client.get_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetRollupPropertySourceLinkRequest() + request_msg = analytics_admin.GetPropertyRequest() assert args[0] == request_msg @@ -92683,28 +92335,26 @@ async def test_get_rollup_property_source_link_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_list_rollup_property_source_links_empty_call_grpc_asyncio(): +async def test_list_properties_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_rollup_property_source_links), "__call__" - ) as call: + with mock.patch.object(type(client.transport.list_properties), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListRollupPropertySourceLinksResponse( + analytics_admin.ListPropertiesResponse( next_page_token="next_page_token_value", ) ) - await client.list_rollup_property_source_links(request=None) + await client.list_properties(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListRollupPropertySourceLinksRequest() + request_msg = analytics_admin.ListPropertiesRequest() assert args[0] == request_msg @@ -92712,29 +92362,34 @@ async def test_list_rollup_property_source_links_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_rollup_property_source_link_empty_call_grpc_asyncio(): +async def test_create_property_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_rollup_property_source_link), "__call__" - ) as call: + with mock.patch.object(type(client.transport.create_property), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - resources.RollupPropertySourceLink( + resources.Property( name="name_value", - source_property="source_property_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_value", ) ) - await client.create_rollup_property_source_link(request=None) + await client.create_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateRollupPropertySourceLinkRequest() + request_msg = analytics_admin.CreatePropertyRequest() assert args[0] == request_msg @@ -92742,24 +92397,34 @@ async def test_create_rollup_property_source_link_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_rollup_property_source_link_empty_call_grpc_asyncio(): +async def test_delete_property_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_rollup_property_source_link), "__call__" - ) as call: + with mock.patch.object(type(client.transport.delete_property), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_rollup_property_source_link(request=None) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.Property( + name="name_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_value", + ) + ) + await client.delete_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.DeleteRollupPropertySourceLinkRequest() + request_msg = analytics_admin.DeletePropertyRequest() assert args[0] == request_msg @@ -92767,26 +92432,34 @@ async def test_delete_rollup_property_source_link_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_provision_subproperty_empty_call_grpc_asyncio(): +async def test_update_property_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.provision_subproperty), "__call__" - ) as call: + with mock.patch.object(type(client.transport.update_property), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ProvisionSubpropertyResponse() + resources.Property( + name="name_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_value", + ) ) - await client.provision_subproperty(request=None) + await client.update_property(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ProvisionSubpropertyRequest() + request_msg = analytics_admin.UpdatePropertyRequest() assert args[0] == request_msg @@ -92794,7 +92467,7 @@ async def test_provision_subproperty_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_subproperty_event_filter_empty_call_grpc_asyncio(): +async def test_create_firebase_link_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -92802,21 +92475,21 @@ async def test_create_subproperty_event_filter_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_subproperty_event_filter), "__call__" + type(client.transport.create_firebase_link), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_subproperty_event_filter.SubpropertyEventFilter( + resources.FirebaseLink( name="name_value", - apply_to_property="apply_to_property_value", + project="project_value", ) ) - await client.create_subproperty_event_filter(request=None) + await client.create_firebase_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.CreateSubpropertyEventFilterRequest() + request_msg = analytics_admin.CreateFirebaseLinkRequest() assert args[0] == request_msg @@ -92824,7 +92497,7 @@ async def test_create_subproperty_event_filter_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_get_subproperty_event_filter_empty_call_grpc_asyncio(): +async def test_delete_firebase_link_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -92832,21 +92505,16 @@ async def test_get_subproperty_event_filter_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_subproperty_event_filter), "__call__" + type(client.transport.delete_firebase_link), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - subproperty_event_filter.SubpropertyEventFilter( - name="name_value", - apply_to_property="apply_to_property_value", - ) - ) - await client.get_subproperty_event_filter(request=None) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_firebase_link(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.GetSubpropertyEventFilterRequest() + request_msg = analytics_admin.DeleteFirebaseLinkRequest() assert args[0] == request_msg @@ -92854,7 +92522,7 @@ async def test_get_subproperty_event_filter_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_list_subproperty_event_filters_empty_call_grpc_asyncio(): +async def test_list_firebase_links_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -92862,20 +92530,20 @@ async def test_list_subproperty_event_filters_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.list_subproperty_event_filters), "__call__" + type(client.transport.list_firebase_links), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - analytics_admin.ListSubpropertyEventFiltersResponse( + analytics_admin.ListFirebaseLinksResponse( next_page_token="next_page_token_value", ) ) - await client.list_subproperty_event_filters(request=None) + await client.list_firebase_links(request=None) # Establish that the underlying stub method was called. call.assert_called() _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.ListSubpropertyEventFiltersRequest() + request_msg = analytics_admin.ListFirebaseLinksRequest() assert args[0] == request_msg @@ -92883,7 +92551,7 @@ async def test_list_subproperty_event_filters_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_subproperty_event_filter_empty_call_grpc_asyncio(): +async def test_get_global_site_tag_empty_call_grpc_asyncio(): client = AnalyticsAdminServiceAsyncClient( credentials=async_anonymous_credentials(), transport="grpc_asyncio", @@ -92891,63 +92559,6201 @@ async def test_update_subproperty_event_filter_empty_call_grpc_asyncio(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_subproperty_event_filter), "__call__" + type(client.transport.get_global_site_tag), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gaa_subproperty_event_filter.SubpropertyEventFilter( + resources.GlobalSiteTag( name="name_value", - apply_to_property="apply_to_property_value", + snippet="snippet_value", ) ) - await client.update_subproperty_event_filter(request=None) + await client.get_global_site_tag(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetGlobalSiteTagRequest() + + 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_google_ads_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_google_ads_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.GoogleAdsLink( + name="name_value", + customer_id="customer_id_value", + can_manage_clients=True, + creator_email_address="creator_email_address_value", + ) + ) + await client.create_google_ads_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateGoogleAdsLinkRequest() + + 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_google_ads_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_google_ads_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.GoogleAdsLink( + name="name_value", + customer_id="customer_id_value", + can_manage_clients=True, + creator_email_address="creator_email_address_value", + ) + ) + await client.update_google_ads_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateGoogleAdsLinkRequest() + + 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_google_ads_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_google_ads_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_google_ads_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteGoogleAdsLinkRequest() + + 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_google_ads_links_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_google_ads_links), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListGoogleAdsLinksResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_google_ads_links(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListGoogleAdsLinksRequest() + + 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_data_sharing_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_data_sharing_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataSharingSettings( + name="name_value", + sharing_with_google_support_enabled=True, + sharing_with_google_assigned_sales_enabled=True, + sharing_with_google_any_sales_enabled=True, + sharing_with_google_products_enabled=True, + sharing_with_others_enabled=True, + ) + ) + await client.get_data_sharing_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetDataSharingSettingsRequest() + + 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_measurement_protocol_secret_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_measurement_protocol_secret), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.MeasurementProtocolSecret( + name="name_value", + display_name="display_name_value", + secret_value="secret_value_value", + ) + ) + await client.get_measurement_protocol_secret(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetMeasurementProtocolSecretRequest() + + 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_measurement_protocol_secrets_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_measurement_protocol_secrets), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListMeasurementProtocolSecretsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_measurement_protocol_secrets(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListMeasurementProtocolSecretsRequest() + + 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_measurement_protocol_secret_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_measurement_protocol_secret), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.MeasurementProtocolSecret( + name="name_value", + display_name="display_name_value", + secret_value="secret_value_value", + ) + ) + await client.create_measurement_protocol_secret(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateMeasurementProtocolSecretRequest() + + 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_measurement_protocol_secret_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_measurement_protocol_secret), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_measurement_protocol_secret(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteMeasurementProtocolSecretRequest() + + 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_measurement_protocol_secret_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_measurement_protocol_secret), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.MeasurementProtocolSecret( + name="name_value", + display_name="display_name_value", + secret_value="secret_value_value", + ) + ) + await client.update_measurement_protocol_secret(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateMeasurementProtocolSecretRequest() + + 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_acknowledge_user_data_collection_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.acknowledge_user_data_collection), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.AcknowledgeUserDataCollectionResponse() + ) + await client.acknowledge_user_data_collection(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.AcknowledgeUserDataCollectionRequest() + + 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_sk_ad_network_conversion_value_schema), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.SKAdNetworkConversionValueSchema( + name="name_value", + apply_conversion_values=True, + ) + ) + await client.get_sk_ad_network_conversion_value_schema(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() + + 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_sk_ad_network_conversion_value_schema), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.SKAdNetworkConversionValueSchema( + name="name_value", + apply_conversion_values=True, + ) + ) + await client.create_sk_ad_network_conversion_value_schema(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() + + 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_sk_ad_network_conversion_value_schema), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_sk_ad_network_conversion_value_schema(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() + + 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_sk_ad_network_conversion_value_schema_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_sk_ad_network_conversion_value_schema), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.SKAdNetworkConversionValueSchema( + name="name_value", + apply_conversion_values=True, + ) + ) + await client.update_sk_ad_network_conversion_value_schema(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() + + 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_sk_ad_network_conversion_value_schemas_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_sk_ad_network_conversion_value_schemas), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_sk_ad_network_conversion_value_schemas(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() + + 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_search_change_history_events_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.search_change_history_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.SearchChangeHistoryEventsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.search_change_history_events(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.SearchChangeHistoryEventsRequest() + + 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_google_signals_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_google_signals_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.GoogleSignalsSettings( + name="name_value", + state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, + consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, + ) + ) + await client.get_google_signals_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetGoogleSignalsSettingsRequest() + + 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_google_signals_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_google_signals_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.GoogleSignalsSettings( + name="name_value", + state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, + consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, + ) + ) + await client.update_google_signals_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateGoogleSignalsSettingsRequest() + + 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_conversion_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_conversion_event), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ConversionEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + ) + ) + await client.create_conversion_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateConversionEventRequest() + + 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_conversion_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_conversion_event), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ConversionEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + ) + ) + await client.update_conversion_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateConversionEventRequest() + + 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_conversion_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_conversion_event), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ConversionEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + ) + ) + await client.get_conversion_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetConversionEventRequest() + + 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_conversion_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_conversion_event), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_conversion_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteConversionEventRequest() + + 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_conversion_events_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_conversion_events), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListConversionEventsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_conversion_events(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListConversionEventsRequest() + + 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_key_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_key_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.KeyEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, + ) + ) + await client.create_key_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateKeyEventRequest() + + 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_key_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_key_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.KeyEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, + ) + ) + await client.update_key_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateKeyEventRequest() + + 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_key_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_key_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.KeyEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, + ) + ) + await client.get_key_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetKeyEventRequest() + + 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_key_event_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_key_event), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_key_event(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteKeyEventRequest() + + 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_key_events_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_key_events), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListKeyEventsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_key_events(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListKeyEventsRequest() + + 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_display_video360_advertiser_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DisplayVideo360AdvertiserLink( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + ) + ) + await client.get_display_video360_advertiser_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() + + 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_display_video360_advertiser_links_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_display_video360_advertiser_links), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_display_video360_advertiser_links(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() + + 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_display_video360_advertiser_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DisplayVideo360AdvertiserLink( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + ) + ) + await client.create_display_video360_advertiser_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() + + 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_display_video360_advertiser_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_display_video360_advertiser_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() + + 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_display_video360_advertiser_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_display_video360_advertiser_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DisplayVideo360AdvertiserLink( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + ) + ) + await client.update_display_video360_advertiser_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() + + 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_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_display_video360_advertiser_link_proposal), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DisplayVideo360AdvertiserLinkProposal( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + validation_email="validation_email_value", + ) + ) + await client.get_display_video360_advertiser_link_proposal(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() + + 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_display_video360_advertiser_link_proposals_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_display_video360_advertiser_link_proposals), + "__call__", + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_display_video360_advertiser_link_proposals(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() + ) + + 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_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_display_video360_advertiser_link_proposal), + "__call__", + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DisplayVideo360AdvertiserLinkProposal( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + validation_email="validation_email_value", + ) + ) + await client.create_display_video360_advertiser_link_proposal(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = ( + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() + ) + + 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_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_display_video360_advertiser_link_proposal), + "__call__", + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_display_video360_advertiser_link_proposal(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = ( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() + ) + + 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_approve_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.approve_display_video360_advertiser_link_proposal), + "__call__", + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + ) + await client.approve_display_video360_advertiser_link_proposal(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() + ) + + 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_cancel_display_video360_advertiser_link_proposal_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.cancel_display_video360_advertiser_link_proposal), + "__call__", + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DisplayVideo360AdvertiserLinkProposal( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + validation_email="validation_email_value", + ) + ) + await client.cancel_display_video360_advertiser_link_proposal(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = ( + analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() + ) + + 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_custom_dimension_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_custom_dimension), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CustomDimension( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + scope=resources.CustomDimension.DimensionScope.EVENT, + disallow_ads_personalization=True, + ) + ) + await client.create_custom_dimension(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateCustomDimensionRequest() + + 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_custom_dimension_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_custom_dimension), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CustomDimension( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + scope=resources.CustomDimension.DimensionScope.EVENT, + disallow_ads_personalization=True, + ) + ) + await client.update_custom_dimension(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateCustomDimensionRequest() + + 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_custom_dimensions_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_custom_dimensions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListCustomDimensionsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_custom_dimensions(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListCustomDimensionsRequest() + + 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_archive_custom_dimension_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.archive_custom_dimension), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.archive_custom_dimension(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ArchiveCustomDimensionRequest() + + 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_custom_dimension_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_custom_dimension), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CustomDimension( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + scope=resources.CustomDimension.DimensionScope.EVENT, + disallow_ads_personalization=True, + ) + ) + await client.get_custom_dimension(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetCustomDimensionRequest() + + 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_custom_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_custom_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CustomMetric( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, + scope=resources.CustomMetric.MetricScope.EVENT, + restricted_metric_type=[ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ], + ) + ) + await client.create_custom_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateCustomMetricRequest() + + 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_custom_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_custom_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CustomMetric( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, + scope=resources.CustomMetric.MetricScope.EVENT, + restricted_metric_type=[ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ], + ) + ) + await client.update_custom_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateCustomMetricRequest() + + 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_custom_metrics_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_custom_metrics), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListCustomMetricsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_custom_metrics(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListCustomMetricsRequest() + + 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_archive_custom_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.archive_custom_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.archive_custom_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ArchiveCustomMetricRequest() + + 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_custom_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_custom_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CustomMetric( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, + scope=resources.CustomMetric.MetricScope.EVENT, + restricted_metric_type=[ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ], + ) + ) + await client.get_custom_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetCustomMetricRequest() + + 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_data_retention_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_data_retention_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataRetentionSettings( + name="name_value", + event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + reset_user_data_on_new_activity=True, + ) + ) + await client.get_data_retention_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetDataRetentionSettingsRequest() + + 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_data_retention_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_data_retention_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataRetentionSettings( + name="name_value", + event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + reset_user_data_on_new_activity=True, + ) + ) + await client.update_data_retention_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateDataRetentionSettingsRequest() + + 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_data_stream_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_data_stream), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataStream( + name="name_value", + type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, + display_name="display_name_value", + ) + ) + await client.create_data_stream(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateDataStreamRequest() + + 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_data_stream_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_data_stream), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_data_stream(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteDataStreamRequest() + + 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_data_stream_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_data_stream), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataStream( + name="name_value", + type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, + display_name="display_name_value", + ) + ) + await client.update_data_stream(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateDataStreamRequest() + + 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_data_streams_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_data_streams), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListDataStreamsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_data_streams(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListDataStreamsRequest() + + 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_data_stream_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_data_stream), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataStream( + name="name_value", + type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, + display_name="display_name_value", + ) + ) + await client.get_data_stream(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetDataStreamRequest() + + 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_audience_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_audience), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + audience.Audience( + name="name_value", + display_name="display_name_value", + description="description_value", + membership_duration_days=2561, + ads_personalization_enabled=True, + exclusion_duration_mode=audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + ) + ) + await client.get_audience(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetAudienceRequest() + + 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_audiences_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_audiences), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListAudiencesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_audiences(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListAudiencesRequest() + + 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_audience_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_audience), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_audience.Audience( + name="name_value", + display_name="display_name_value", + description="description_value", + membership_duration_days=2561, + ads_personalization_enabled=True, + exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + ) + ) + await client.create_audience(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateAudienceRequest() + + 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_audience_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_audience), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_audience.Audience( + name="name_value", + display_name="display_name_value", + description="description_value", + membership_duration_days=2561, + ads_personalization_enabled=True, + exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + ) + ) + await client.update_audience(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateAudienceRequest() + + 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_archive_audience_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.archive_audience), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.archive_audience(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ArchiveAudienceRequest() + + 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_search_ads360_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_search_ads360_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.SearchAds360Link( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + ) + ) + await client.get_search_ads360_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetSearchAds360LinkRequest() + + 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_search_ads360_links_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_search_ads360_links), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListSearchAds360LinksResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_search_ads360_links(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListSearchAds360LinksRequest() + + 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_search_ads360_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_search_ads360_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.SearchAds360Link( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + ) + ) + await client.create_search_ads360_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateSearchAds360LinkRequest() + + 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_search_ads360_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_search_ads360_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_search_ads360_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteSearchAds360LinkRequest() + + 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_search_ads360_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_search_ads360_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.SearchAds360Link( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + ) + ) + await client.update_search_ads360_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateSearchAds360LinkRequest() + + 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_attribution_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_attribution_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AttributionSettings( + name="name_value", + acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, + other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, + reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, + ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, + ) + ) + await client.get_attribution_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetAttributionSettingsRequest() + + 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_attribution_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_attribution_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AttributionSettings( + name="name_value", + acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, + other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, + reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, + ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, + ) + ) + await client.update_attribution_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateAttributionSettingsRequest() + + 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_run_access_report_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.run_access_report), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.RunAccessReportResponse( + row_count=992, + ) + ) + await client.run_access_report(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.RunAccessReportRequest() + + 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_access_binding_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_access_binding), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AccessBinding( + name="name_value", + roles=["roles_value"], + ) + ) + await client.create_access_binding(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateAccessBindingRequest() + + 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_access_binding_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_access_binding), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AccessBinding( + name="name_value", + roles=["roles_value"], + ) + ) + await client.get_access_binding(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetAccessBindingRequest() + + 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_access_binding_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_access_binding), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AccessBinding( + name="name_value", + roles=["roles_value"], + ) + ) + await client.update_access_binding(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateAccessBindingRequest() + + 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_access_binding_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_access_binding), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_access_binding(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteAccessBindingRequest() + + 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_access_bindings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_access_bindings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListAccessBindingsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_access_bindings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListAccessBindingsRequest() + + 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_batch_create_access_bindings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.batch_create_access_bindings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.BatchCreateAccessBindingsResponse() + ) + await client.batch_create_access_bindings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.BatchCreateAccessBindingsRequest() + + 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_batch_get_access_bindings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.batch_get_access_bindings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.BatchGetAccessBindingsResponse() + ) + await client.batch_get_access_bindings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.BatchGetAccessBindingsRequest() + + 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_batch_update_access_bindings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.batch_update_access_bindings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.BatchUpdateAccessBindingsResponse() + ) + await client.batch_update_access_bindings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.BatchUpdateAccessBindingsRequest() + + 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_batch_delete_access_bindings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.batch_delete_access_bindings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.batch_delete_access_bindings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.BatchDeleteAccessBindingsRequest() + + 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_expanded_data_set_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_expanded_data_set), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + expanded_data_set.ExpandedDataSet( + name="name_value", + display_name="display_name_value", + description="description_value", + dimension_names=["dimension_names_value"], + metric_names=["metric_names_value"], + ) + ) + await client.get_expanded_data_set(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetExpandedDataSetRequest() + + 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_expanded_data_sets_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_expanded_data_sets), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListExpandedDataSetsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_expanded_data_sets(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListExpandedDataSetsRequest() + + 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_expanded_data_set_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_expanded_data_set), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_expanded_data_set.ExpandedDataSet( + name="name_value", + display_name="display_name_value", + description="description_value", + dimension_names=["dimension_names_value"], + metric_names=["metric_names_value"], + ) + ) + await client.create_expanded_data_set(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateExpandedDataSetRequest() + + 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_expanded_data_set_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_expanded_data_set), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_expanded_data_set.ExpandedDataSet( + name="name_value", + display_name="display_name_value", + description="description_value", + dimension_names=["dimension_names_value"], + metric_names=["metric_names_value"], + ) + ) + await client.update_expanded_data_set(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateExpandedDataSetRequest() + + 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_expanded_data_set_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_expanded_data_set), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_expanded_data_set(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteExpandedDataSetRequest() + + 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_channel_group_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_channel_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + channel_group.ChannelGroup( + name="name_value", + display_name="display_name_value", + description="description_value", + system_defined=True, + primary=True, + ) + ) + await client.get_channel_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetChannelGroupRequest() + + 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_channel_groups_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_channel_groups), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListChannelGroupsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_channel_groups(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListChannelGroupsRequest() + + 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_channel_group_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_channel_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_channel_group.ChannelGroup( + name="name_value", + display_name="display_name_value", + description="description_value", + system_defined=True, + primary=True, + ) + ) + await client.create_channel_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateChannelGroupRequest() + + 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_channel_group_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_channel_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_channel_group.ChannelGroup( + name="name_value", + display_name="display_name_value", + description="description_value", + system_defined=True, + primary=True, + ) + ) + await client.update_channel_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateChannelGroupRequest() + + 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_channel_group_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_channel_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_channel_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteChannelGroupRequest() + + 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_set_automated_ga4_configuration_opt_out_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.set_automated_ga4_configuration_opt_out), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + ) + await client.set_automated_ga4_configuration_opt_out(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() + + 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_automated_ga4_configuration_opt_out_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.fetch_automated_ga4_configuration_opt_out), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse( + opt_out=True, + ) + ) + await client.fetch_automated_ga4_configuration_opt_out(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() + + 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_big_query_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_big_query_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.BigQueryLink( + name="name_value", + project="project_value", + daily_export_enabled=True, + streaming_export_enabled=True, + fresh_daily_export_enabled=True, + include_advertising_id=True, + export_streams=["export_streams_value"], + excluded_events=["excluded_events_value"], + dataset_location="dataset_location_value", + ) + ) + await client.create_big_query_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateBigQueryLinkRequest() + + 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_big_query_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_big_query_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.BigQueryLink( + name="name_value", + project="project_value", + daily_export_enabled=True, + streaming_export_enabled=True, + fresh_daily_export_enabled=True, + include_advertising_id=True, + export_streams=["export_streams_value"], + excluded_events=["excluded_events_value"], + dataset_location="dataset_location_value", + ) + ) + await client.get_big_query_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetBigQueryLinkRequest() + + 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_big_query_links_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_big_query_links), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListBigQueryLinksResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_big_query_links(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListBigQueryLinksRequest() + + 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_big_query_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_big_query_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_big_query_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteBigQueryLinkRequest() + + 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_big_query_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_big_query_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.BigQueryLink( + name="name_value", + project="project_value", + daily_export_enabled=True, + streaming_export_enabled=True, + fresh_daily_export_enabled=True, + include_advertising_id=True, + export_streams=["export_streams_value"], + excluded_events=["excluded_events_value"], + dataset_location="dataset_location_value", + ) + ) + await client.update_big_query_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateBigQueryLinkRequest() + + 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_enhanced_measurement_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_enhanced_measurement_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.EnhancedMeasurementSettings( + name="name_value", + stream_enabled=True, + scrolls_enabled=True, + outbound_clicks_enabled=True, + site_search_enabled=True, + video_engagement_enabled=True, + file_downloads_enabled=True, + page_changes_enabled=True, + form_interactions_enabled=True, + search_query_parameter="search_query_parameter_value", + uri_query_parameter="uri_query_parameter_value", + ) + ) + await client.get_enhanced_measurement_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetEnhancedMeasurementSettingsRequest() + + 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_enhanced_measurement_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_enhanced_measurement_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.EnhancedMeasurementSettings( + name="name_value", + stream_enabled=True, + scrolls_enabled=True, + outbound_clicks_enabled=True, + site_search_enabled=True, + video_engagement_enabled=True, + file_downloads_enabled=True, + page_changes_enabled=True, + form_interactions_enabled=True, + search_query_parameter="search_query_parameter_value", + uri_query_parameter="uri_query_parameter_value", + ) + ) + await client.update_enhanced_measurement_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateEnhancedMeasurementSettingsRequest() + + 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_connected_site_tag_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_connected_site_tag), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.CreateConnectedSiteTagResponse() + ) + await client.create_connected_site_tag(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateConnectedSiteTagRequest() + + 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_connected_site_tag_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_connected_site_tag), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_connected_site_tag(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteConnectedSiteTagRequest() + + 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_connected_site_tags_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_connected_site_tags), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListConnectedSiteTagsResponse() + ) + await client.list_connected_site_tags(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListConnectedSiteTagsRequest() + + 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_connected_ga4_property_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.fetch_connected_ga4_property), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.FetchConnectedGa4PropertyResponse( + property="property_value", + ) + ) + await client.fetch_connected_ga4_property(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.FetchConnectedGa4PropertyRequest() + + 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_ad_sense_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_ad_sense_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AdSenseLink( + name="name_value", + ad_client_code="ad_client_code_value", + ) + ) + await client.get_ad_sense_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetAdSenseLinkRequest() + + 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_ad_sense_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_ad_sense_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.AdSenseLink( + name="name_value", + ad_client_code="ad_client_code_value", + ) + ) + await client.create_ad_sense_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateAdSenseLinkRequest() + + 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_ad_sense_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_ad_sense_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_ad_sense_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteAdSenseLinkRequest() + + 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_ad_sense_links_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_ad_sense_links), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListAdSenseLinksResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_ad_sense_links(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListAdSenseLinksRequest() + + 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_event_create_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_event_create_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + event_create_and_edit.EventCreateRule( + name="name_value", + destination_event="destination_event_value", + source_copy_parameters=True, + ) + ) + await client.get_event_create_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetEventCreateRuleRequest() + + 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_event_create_rules_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_event_create_rules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListEventCreateRulesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_event_create_rules(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListEventCreateRulesRequest() + + 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_event_create_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_event_create_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + event_create_and_edit.EventCreateRule( + name="name_value", + destination_event="destination_event_value", + source_copy_parameters=True, + ) + ) + await client.create_event_create_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateEventCreateRuleRequest() + + 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_event_create_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_event_create_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + event_create_and_edit.EventCreateRule( + name="name_value", + destination_event="destination_event_value", + source_copy_parameters=True, + ) + ) + await client.update_event_create_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateEventCreateRuleRequest() + + 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_event_create_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_event_create_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_event_create_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteEventCreateRuleRequest() + + 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_event_edit_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_event_edit_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + event_create_and_edit.EventEditRule( + name="name_value", + display_name="display_name_value", + processing_order=1720, + ) + ) + await client.get_event_edit_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetEventEditRuleRequest() + + 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_event_edit_rules_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_event_edit_rules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListEventEditRulesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_event_edit_rules(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListEventEditRulesRequest() + + 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_event_edit_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_event_edit_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + event_create_and_edit.EventEditRule( + name="name_value", + display_name="display_name_value", + processing_order=1720, + ) + ) + await client.create_event_edit_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateEventEditRuleRequest() + + 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_event_edit_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_event_edit_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + event_create_and_edit.EventEditRule( + name="name_value", + display_name="display_name_value", + processing_order=1720, + ) + ) + await client.update_event_edit_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateEventEditRuleRequest() + + 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_event_edit_rule_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_event_edit_rule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_event_edit_rule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteEventEditRuleRequest() + + 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_reorder_event_edit_rules_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.reorder_event_edit_rules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.reorder_event_edit_rules(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ReorderEventEditRulesRequest() + + 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_data_redaction_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_data_redaction_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataRedactionSettings( + name="name_value", + email_redaction_enabled=True, + query_parameter_redaction_enabled=True, + query_parameter_keys=["query_parameter_keys_value"], + ) + ) + await client.update_data_redaction_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateDataRedactionSettingsRequest() + + 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_data_redaction_settings_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_data_redaction_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.DataRedactionSettings( + name="name_value", + email_redaction_enabled=True, + query_parameter_redaction_enabled=True, + query_parameter_keys=["query_parameter_keys_value"], + ) + ) + await client.get_data_redaction_settings(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetDataRedactionSettingsRequest() + + 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_calculated_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_calculated_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CalculatedMetric( + name="name_value", + description="description_value", + display_name="display_name_value", + calculated_metric_id="calculated_metric_id_value", + metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, + restricted_metric_type=[ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ], + formula="formula_value", + invalid_metric_reference=True, + ) + ) + await client.get_calculated_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetCalculatedMetricRequest() + + 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_calculated_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_calculated_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CalculatedMetric( + name="name_value", + description="description_value", + display_name="display_name_value", + calculated_metric_id="calculated_metric_id_value", + metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, + restricted_metric_type=[ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ], + formula="formula_value", + invalid_metric_reference=True, + ) + ) + await client.create_calculated_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateCalculatedMetricRequest() + + 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_calculated_metrics_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_calculated_metrics), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListCalculatedMetricsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_calculated_metrics(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListCalculatedMetricsRequest() + + 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_calculated_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_calculated_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.CalculatedMetric( + name="name_value", + description="description_value", + display_name="display_name_value", + calculated_metric_id="calculated_metric_id_value", + metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, + restricted_metric_type=[ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ], + formula="formula_value", + invalid_metric_reference=True, + ) + ) + await client.update_calculated_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateCalculatedMetricRequest() + + 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_calculated_metric_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_calculated_metric), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_calculated_metric(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteCalculatedMetricRequest() + + 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_rollup_property_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_rollup_property), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.CreateRollupPropertyResponse() + ) + await client.create_rollup_property(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateRollupPropertyRequest() + + 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_rollup_property_source_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_rollup_property_source_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.RollupPropertySourceLink( + name="name_value", + source_property="source_property_value", + ) + ) + await client.get_rollup_property_source_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetRollupPropertySourceLinkRequest() + + 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_rollup_property_source_links_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_rollup_property_source_links), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListRollupPropertySourceLinksResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_rollup_property_source_links(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListRollupPropertySourceLinksRequest() + + 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_rollup_property_source_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_rollup_property_source_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.RollupPropertySourceLink( + name="name_value", + source_property="source_property_value", + ) + ) + await client.create_rollup_property_source_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateRollupPropertySourceLinkRequest() + + 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_rollup_property_source_link_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_rollup_property_source_link), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_rollup_property_source_link(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteRollupPropertySourceLinkRequest() + + 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_provision_subproperty_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.provision_subproperty), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ProvisionSubpropertyResponse() + ) + await client.provision_subproperty(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ProvisionSubpropertyRequest() + + 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_subproperty_event_filter_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_subproperty_event_filter), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_subproperty_event_filter.SubpropertyEventFilter( + name="name_value", + apply_to_property="apply_to_property_value", + ) + ) + await client.create_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateSubpropertyEventFilterRequest() + + 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_subproperty_event_filter_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_subproperty_event_filter), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + subproperty_event_filter.SubpropertyEventFilter( + name="name_value", + apply_to_property="apply_to_property_value", + ) + ) + await client.get_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetSubpropertyEventFilterRequest() + + 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_subproperty_event_filters_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_subproperty_event_filters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListSubpropertyEventFiltersResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_subproperty_event_filters(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListSubpropertyEventFiltersRequest() + + 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_subproperty_event_filter_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_subproperty_event_filter), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gaa_subproperty_event_filter.SubpropertyEventFilter( + name="name_value", + apply_to_property="apply_to_property_value", + ) + ) + await client.update_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateSubpropertyEventFilterRequest() + + 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_subproperty_event_filter_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_subproperty_event_filter), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_subproperty_event_filter(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteSubpropertyEventFilterRequest() + + 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_reporting_data_annotation_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + ) + await client.create_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateReportingDataAnnotationRequest() + + 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_reporting_data_annotation_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + ) + await client.get_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetReportingDataAnnotationRequest() + + 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_reporting_data_annotations_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.ListReportingDataAnnotationsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_reporting_data_annotations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListReportingDataAnnotationsRequest() + + 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_reporting_data_annotation_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + resources.ReportingDataAnnotation( + name="name_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, + ) + ) + await client.update_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateReportingDataAnnotationRequest() + + 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_reporting_data_annotation_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteReportingDataAnnotationRequest() + + 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_submit_user_deletion_empty_call_grpc_asyncio(): + client = AnalyticsAdminServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + analytics_admin.SubmitUserDeletionResponse() + ) + await client.submit_user_deletion(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.SubmitUserDeletionRequest() + + assert args[0] == request_msg + + +def test_transport_kind_rest(): + transport = AnalyticsAdminServiceClient.get_transport_class("rest")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "rest" + + +def test_get_account_rest_bad_request(request_type=analytics_admin.GetAccountRequest): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "accounts/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_account(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetAccountRequest, + dict, + ], +) +def test_get_account_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "accounts/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.Account( + name="name_value", + display_name="display_name_value", + region_code="region_code_value", + deleted=True, + gmp_organization="gmp_organization_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.Account.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_account(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Account) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.region_code == "region_code_value" + assert response.deleted is True + assert response.gmp_organization == "gmp_organization_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_account_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_get_account" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_account_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_account" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetAccountRequest.pb( + analytics_admin.GetAccountRequest() + ) + 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.Account.to_json(resources.Account()) + req.return_value.content = return_value + + request = analytics_admin.GetAccountRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Account() + post_with_metadata.return_value = resources.Account(), metadata + + client.get_account( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_accounts_rest_bad_request( + request_type=analytics_admin.ListAccountsRequest, +): + client = AnalyticsAdminServiceClient( + 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_accounts(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.ListAccountsRequest, + dict, + ], +) +def test_list_accounts_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + 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 = analytics_admin.ListAccountsResponse( + 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 = analytics_admin.ListAccountsResponse.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_accounts(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListAccountsPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_accounts_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_list_accounts" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_accounts_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_accounts" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ListAccountsRequest.pb( + analytics_admin.ListAccountsRequest() + ) + 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 = analytics_admin.ListAccountsResponse.to_json( + analytics_admin.ListAccountsResponse() + ) + req.return_value.content = return_value + + request = analytics_admin.ListAccountsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = analytics_admin.ListAccountsResponse() + post_with_metadata.return_value = ( + analytics_admin.ListAccountsResponse(), + metadata, + ) + + client.list_accounts( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_delete_account_rest_bad_request( + request_type=analytics_admin.DeleteAccountRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "accounts/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.delete_account(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.DeleteAccountRequest, + dict, + ], +) +def test_delete_account_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "accounts/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 = 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_account(request) + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_account_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "pre_delete_account" + ) as pre: + pre.assert_not_called() + pb_message = analytics_admin.DeleteAccountRequest.pb( + analytics_admin.DeleteAccountRequest() + ) + 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"} + + request = analytics_admin.DeleteAccountRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + + client.delete_account( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + + +def test_update_account_rest_bad_request( + request_type=analytics_admin.UpdateAccountRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"account": {"name": "accounts/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.update_account(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.UpdateAccountRequest, + dict, + ], +) +def test_update_account_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"account": {"name": "accounts/sample1"}} + request_init["account"] = { + "name": "accounts/sample1", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "display_name": "display_name_value", + "region_code": "region_code_value", + "deleted": True, + "gmp_organization": "gmp_organization_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateAccountRequest.meta.fields["account"] + + 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["account"].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["account"][field])): + del request_init["account"][field][i][subfield] + else: + del request_init["account"][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 = resources.Account( + name="name_value", + display_name="display_name_value", + region_code="region_code_value", + deleted=True, + gmp_organization="gmp_organization_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.Account.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_account(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Account) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.region_code == "region_code_value" + assert response.deleted is True + assert response.gmp_organization == "gmp_organization_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_account_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_update_account" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_account_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_account" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdateAccountRequest.pb( + analytics_admin.UpdateAccountRequest() + ) + 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.Account.to_json(resources.Account()) + req.return_value.content = return_value + + request = analytics_admin.UpdateAccountRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Account() + post_with_metadata.return_value = resources.Account(), metadata + + client.update_account( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_provision_account_ticket_rest_bad_request( + request_type=analytics_admin.ProvisionAccountTicketRequest, +): + client = AnalyticsAdminServiceClient( + 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.provision_account_ticket(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.ProvisionAccountTicketRequest, + dict, + ], +) +def test_provision_account_ticket_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + 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 = analytics_admin.ProvisionAccountTicketResponse( + account_ticket_id="account_ticket_id_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 = analytics_admin.ProvisionAccountTicketResponse.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.provision_account_ticket(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, analytics_admin.ProvisionAccountTicketResponse) + assert response.account_ticket_id == "account_ticket_id_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_provision_account_ticket_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_provision_account_ticket" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_provision_account_ticket_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_provision_account_ticket" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ProvisionAccountTicketRequest.pb( + analytics_admin.ProvisionAccountTicketRequest() + ) + 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 = analytics_admin.ProvisionAccountTicketResponse.to_json( + analytics_admin.ProvisionAccountTicketResponse() + ) + req.return_value.content = return_value + + request = analytics_admin.ProvisionAccountTicketRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = analytics_admin.ProvisionAccountTicketResponse() + post_with_metadata.return_value = ( + analytics_admin.ProvisionAccountTicketResponse(), + metadata, + ) + + client.provision_account_ticket( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_account_summaries_rest_bad_request( + request_type=analytics_admin.ListAccountSummariesRequest, +): + client = AnalyticsAdminServiceClient( + 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_account_summaries(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.ListAccountSummariesRequest, + dict, + ], +) +def test_list_account_summaries_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + 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 = analytics_admin.ListAccountSummariesResponse( + 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 = analytics_admin.ListAccountSummariesResponse.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_account_summaries(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListAccountSummariesPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_account_summaries_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_list_account_summaries" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_account_summaries_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_account_summaries" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ListAccountSummariesRequest.pb( + analytics_admin.ListAccountSummariesRequest() + ) + 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 = analytics_admin.ListAccountSummariesResponse.to_json( + analytics_admin.ListAccountSummariesResponse() + ) + req.return_value.content = return_value + + request = analytics_admin.ListAccountSummariesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = analytics_admin.ListAccountSummariesResponse() + post_with_metadata.return_value = ( + analytics_admin.ListAccountSummariesResponse(), + metadata, + ) + + client.list_account_summaries( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_property_rest_bad_request(request_type=analytics_admin.GetPropertyRequest): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "properties/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_property(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetPropertyRequest, + dict, + ], +) +def test_get_property_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "properties/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.Property( + name="name_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_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.Property.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_property(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Property) + assert response.name == "name_value" + assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY + assert response.parent == "parent_value" + assert response.display_name == "display_name_value" + assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE + assert response.time_zone == "time_zone_value" + assert response.currency_code == "currency_code_value" + assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD + assert response.account == "account_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_property_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_get_property" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_property_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_property" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetPropertyRequest.pb( + analytics_admin.GetPropertyRequest() + ) + 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.Property.to_json(resources.Property()) + req.return_value.content = return_value + + request = analytics_admin.GetPropertyRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Property() + post_with_metadata.return_value = resources.Property(), metadata + + client.get_property( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_properties_rest_bad_request( + request_type=analytics_admin.ListPropertiesRequest, +): + client = AnalyticsAdminServiceClient( + 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_properties(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.ListPropertiesRequest, + dict, + ], +) +def test_list_properties_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + 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 = analytics_admin.ListPropertiesResponse( + 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 = analytics_admin.ListPropertiesResponse.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_properties(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListPropertiesPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_properties_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_list_properties" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_properties_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_properties" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ListPropertiesRequest.pb( + analytics_admin.ListPropertiesRequest() + ) + 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 = analytics_admin.ListPropertiesResponse.to_json( + analytics_admin.ListPropertiesResponse() + ) + req.return_value.content = return_value + + request = analytics_admin.ListPropertiesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = analytics_admin.ListPropertiesResponse() + post_with_metadata.return_value = ( + analytics_admin.ListPropertiesResponse(), + metadata, + ) + + client.list_properties( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_create_property_rest_bad_request( + request_type=analytics_admin.CreatePropertyRequest, +): + client = AnalyticsAdminServiceClient( + 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.create_property(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.CreatePropertyRequest, + dict, + ], +) +def test_create_property_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {} + request_init["property"] = { + "name": "name_value", + "property_type": 1, + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "parent": "parent_value", + "display_name": "display_name_value", + "industry_category": 1, + "time_zone": "time_zone_value", + "currency_code": "currency_code_value", + "service_level": 1, + "delete_time": {}, + "expire_time": {}, + "account": "account_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.CreatePropertyRequest.meta.fields["property"] + + 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["property"].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["property"][field])): + del request_init["property"][field][i][subfield] + else: + del request_init["property"][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 = resources.Property( + name="name_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_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.Property.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.create_property(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Property) + assert response.name == "name_value" + assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY + assert response.parent == "parent_value" + assert response.display_name == "display_name_value" + assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE + assert response.time_zone == "time_zone_value" + assert response.currency_code == "currency_code_value" + assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD + assert response.account == "account_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_property_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_create_property" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_property_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_property" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.CreatePropertyRequest.pb( + analytics_admin.CreatePropertyRequest() + ) + 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.Property.to_json(resources.Property()) + req.return_value.content = return_value + + request = analytics_admin.CreatePropertyRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Property() + post_with_metadata.return_value = resources.Property(), metadata + + client.create_property( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_delete_property_rest_bad_request( + request_type=analytics_admin.DeletePropertyRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "properties/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.delete_property(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.DeletePropertyRequest, + dict, + ], +) +def test_delete_property_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "properties/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.Property( + name="name_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_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.Property.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_property(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Property) + assert response.name == "name_value" + assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY + assert response.parent == "parent_value" + assert response.display_name == "display_name_value" + assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE + assert response.time_zone == "time_zone_value" + assert response.currency_code == "currency_code_value" + assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD + assert response.account == "account_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_property_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_delete_property" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_delete_property_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_property" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.DeletePropertyRequest.pb( + analytics_admin.DeletePropertyRequest() + ) + 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.Property.to_json(resources.Property()) + req.return_value.content = return_value + + request = analytics_admin.DeletePropertyRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Property() + post_with_metadata.return_value = resources.Property(), metadata + + client.delete_property( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_update_property_rest_bad_request( + request_type=analytics_admin.UpdatePropertyRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"property": {"name": "properties/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.update_property(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.UpdatePropertyRequest, + dict, + ], +) +def test_update_property_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"property": {"name": "properties/sample1"}} + request_init["property"] = { + "name": "properties/sample1", + "property_type": 1, + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "parent": "parent_value", + "display_name": "display_name_value", + "industry_category": 1, + "time_zone": "time_zone_value", + "currency_code": "currency_code_value", + "service_level": 1, + "delete_time": {}, + "expire_time": {}, + "account": "account_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdatePropertyRequest.meta.fields["property"] + + 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["property"].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["property"][field])): + del request_init["property"][field][i][subfield] + else: + del request_init["property"][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 = resources.Property( + name="name_value", + property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, + parent="parent_value", + display_name="display_name_value", + industry_category=resources.IndustryCategory.AUTOMOTIVE, + time_zone="time_zone_value", + currency_code="currency_code_value", + service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, + account="account_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.Property.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_property(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.Property) + assert response.name == "name_value" + assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY + assert response.parent == "parent_value" + assert response.display_name == "display_name_value" + assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE + assert response.time_zone == "time_zone_value" + assert response.currency_code == "currency_code_value" + assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD + assert response.account == "account_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_property_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_update_property" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_property_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_property" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdatePropertyRequest.pb( + analytics_admin.UpdatePropertyRequest() + ) + 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.Property.to_json(resources.Property()) + req.return_value.content = return_value + + request = analytics_admin.UpdatePropertyRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.Property() + post_with_metadata.return_value = resources.Property(), metadata + + client.update_property( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_create_firebase_link_rest_bad_request( + request_type=analytics_admin.CreateFirebaseLinkRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "properties/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.create_firebase_link(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.CreateFirebaseLinkRequest, + dict, + ], +) +def test_create_firebase_link_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "properties/sample1"} + request_init["firebase_link"] = { + "name": "name_value", + "project": "project_value", + "create_time": {"seconds": 751, "nanos": 543}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.CreateFirebaseLinkRequest.meta.fields["firebase_link"] + + 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["firebase_link"].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["firebase_link"][field])): + del request_init["firebase_link"][field][i][subfield] + else: + del request_init["firebase_link"][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 = resources.FirebaseLink( + name="name_value", + project="project_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = analytics_admin.UpdateSubpropertyEventFilterRequest() + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = resources.FirebaseLink.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.create_firebase_link(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.FirebaseLink) + assert response.name == "name_value" + assert response.project == "project_value" -# 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_subproperty_event_filter_empty_call_grpc_asyncio(): - client = AnalyticsAdminServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_firebase_link_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), ) + client = AnalyticsAdminServiceClient(transport=transport) - # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.delete_subproperty_event_filter), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_subproperty_event_filter(request=None) + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "post_create_firebase_link" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_firebase_link_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_firebase_link" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.CreateFirebaseLinkRequest.pb( + analytics_admin.CreateFirebaseLinkRequest() + ) + 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 = analytics_admin.DeleteSubpropertyEventFilterRequest() + 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.FirebaseLink.to_json(resources.FirebaseLink()) + req.return_value.content = return_value - assert args[0] == request_msg + request = analytics_admin.CreateFirebaseLinkRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.FirebaseLink() + post_with_metadata.return_value = resources.FirebaseLink(), metadata + client.create_firebase_link( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) -def test_transport_kind_rest(): - transport = AnalyticsAdminServiceClient.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_account_rest_bad_request(request_type=analytics_admin.GetAccountRequest): +def test_delete_firebase_link_rest_bad_request( + request_type=analytics_admin.DeleteFirebaseLinkRequest, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1"} + request_init = {"name": "properties/sample1/firebaseLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -92962,59 +98768,45 @@ def test_get_account_rest_bad_request(request_type=analytics_admin.GetAccountReq response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_account(request) + client.delete_firebase_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetAccountRequest, + analytics_admin.DeleteFirebaseLinkRequest, dict, ], ) -def test_get_account_rest_call_success(request_type): +def test_delete_firebase_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1"} + request_init = {"name": "properties/sample1/firebaseLinks/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 = resources.Account( - name="name_value", - display_name="display_name_value", - region_code="region_code_value", - deleted=True, - gmp_organization="gmp_organization_value", - ) + return_value = None # 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.Account.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"} - response = client.get_account(request) + response = client.delete_firebase_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Account) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.region_code == "region_code_value" - assert response.deleted is True - assert response.gmp_organization == "gmp_organization_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_account_rest_interceptors(null_interceptor): +def test_delete_firebase_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -93028,18 +98820,11 @@ def test_get_account_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_account" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_account_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_account" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_firebase_link" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetAccountRequest.pb( - analytics_admin.GetAccountRequest() + pb_message = analytics_admin.DeleteFirebaseLinkRequest.pb( + analytics_admin.DeleteFirebaseLinkRequest() ) transcode.return_value = { "method": "post", @@ -93051,19 +98836,15 @@ def test_get_account_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.Account.to_json(resources.Account()) - req.return_value.content = return_value - request = analytics_admin.GetAccountRequest() + request = analytics_admin.DeleteFirebaseLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Account() - post_with_metadata.return_value = resources.Account(), metadata - client.get_account( + client.delete_firebase_link( request, metadata=[ ("key", "val"), @@ -93072,18 +98853,16 @@ def test_get_account_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_list_accounts_rest_bad_request( - request_type=analytics_admin.ListAccountsRequest, +def test_list_firebase_links_rest_bad_request( + request_type=analytics_admin.ListFirebaseLinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -93098,29 +98877,29 @@ def test_list_accounts_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.list_accounts(request) + client.list_firebase_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListAccountsRequest, + analytics_admin.ListFirebaseLinksRequest, dict, ], ) -def test_list_accounts_rest_call_success(request_type): +def test_list_firebase_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/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 = analytics_admin.ListAccountsResponse( + return_value = analytics_admin.ListFirebaseLinksResponse( next_page_token="next_page_token_value", ) @@ -93129,20 +98908,20 @@ def test_list_accounts_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAccountsResponse.pb(return_value) + return_value = analytics_admin.ListFirebaseLinksResponse.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_accounts(request) + response = client.list_firebase_links(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAccountsPager) + assert isinstance(response, pagers.ListFirebaseLinksPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_accounts_rest_interceptors(null_interceptor): +def test_list_firebase_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -93156,18 +98935,18 @@ def test_list_accounts_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_accounts" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_firebase_links" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_accounts_with_metadata", + "post_list_firebase_links_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_accounts" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_firebase_links" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListAccountsRequest.pb( - analytics_admin.ListAccountsRequest() + pb_message = analytics_admin.ListFirebaseLinksRequest.pb( + analytics_admin.ListFirebaseLinksRequest() ) transcode.return_value = { "method": "post", @@ -93179,24 +98958,24 @@ def test_list_accounts_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 = analytics_admin.ListAccountsResponse.to_json( - analytics_admin.ListAccountsResponse() + return_value = analytics_admin.ListFirebaseLinksResponse.to_json( + analytics_admin.ListFirebaseLinksResponse() ) req.return_value.content = return_value - request = analytics_admin.ListAccountsRequest() + request = analytics_admin.ListFirebaseLinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListAccountsResponse() + post.return_value = analytics_admin.ListFirebaseLinksResponse() post_with_metadata.return_value = ( - analytics_admin.ListAccountsResponse(), + analytics_admin.ListFirebaseLinksResponse(), metadata, ) - client.list_accounts( + client.list_firebase_links( request, metadata=[ ("key", "val"), @@ -93209,14 +98988,14 @@ def test_list_accounts_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_account_rest_bad_request( - request_type=analytics_admin.DeleteAccountRequest, +def test_get_global_site_tag_rest_bad_request( + request_type=analytics_admin.GetGlobalSiteTagRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1"} + request_init = {"name": "properties/sample1/dataStreams/sample2/globalSiteTag"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -93231,45 +99010,53 @@ def test_delete_account_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_account(request) + client.get_global_site_tag(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteAccountRequest, + analytics_admin.GetGlobalSiteTagRequest, dict, ], ) -def test_delete_account_rest_call_success(request_type): +def test_get_global_site_tag_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1"} + request_init = {"name": "properties/sample1/dataStreams/sample2/globalSiteTag"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.GlobalSiteTag( + name="name_value", + snippet="snippet_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.GlobalSiteTag.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_account(request) + response = client.get_global_site_tag(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.GlobalSiteTag) + assert response.name == "name_value" + assert response.snippet == "snippet_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_account_rest_interceptors(null_interceptor): +def test_get_global_site_tag_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -93283,11 +99070,18 @@ def test_delete_account_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_account" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_global_site_tag" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_global_site_tag_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_global_site_tag" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteAccountRequest.pb( - analytics_admin.DeleteAccountRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetGlobalSiteTagRequest.pb( + analytics_admin.GetGlobalSiteTagRequest() ) transcode.return_value = { "method": "post", @@ -93299,15 +99093,19 @@ def test_delete_account_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.GlobalSiteTag.to_json(resources.GlobalSiteTag()) + req.return_value.content = return_value - request = analytics_admin.DeleteAccountRequest() + request = analytics_admin.GetGlobalSiteTagRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.GlobalSiteTag() + post_with_metadata.return_value = resources.GlobalSiteTag(), metadata - client.delete_account( + client.get_global_site_tag( request, metadata=[ ("key", "val"), @@ -93316,16 +99114,18 @@ def test_delete_account_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_update_account_rest_bad_request( - request_type=analytics_admin.UpdateAccountRequest, +def test_create_google_ads_link_rest_bad_request( + request_type=analytics_admin.CreateGoogleAdsLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"account": {"name": "accounts/sample1"}} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -93340,38 +99140,40 @@ def test_update_account_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_account(request) + client.create_google_ads_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateAccountRequest, + analytics_admin.CreateGoogleAdsLinkRequest, dict, ], ) -def test_update_account_rest_call_success(request_type): +def test_create_google_ads_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"account": {"name": "accounts/sample1"}} - request_init["account"] = { - "name": "accounts/sample1", + request_init = {"parent": "properties/sample1"} + request_init["google_ads_link"] = { + "name": "name_value", + "customer_id": "customer_id_value", + "can_manage_clients": True, + "ads_personalization_enabled": {"value": True}, "create_time": {"seconds": 751, "nanos": 543}, "update_time": {}, - "display_name": "display_name_value", - "region_code": "region_code_value", - "deleted": True, - "gmp_organization": "gmp_organization_value", + "creator_email_address": "creator_email_address_value", } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateAccountRequest.meta.fields["account"] + test_field = analytics_admin.CreateGoogleAdsLinkRequest.meta.fields[ + "google_ads_link" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -93399,7 +99201,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["account"].items(): # pragma: NO COVER + for field, value in request_init["google_ads_link"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -93429,21 +99231,20 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["account"][field])): - del request_init["account"][field][i][subfield] + for i in range(0, len(request_init["google_ads_link"][field])): + del request_init["google_ads_link"][field][i][subfield] else: - del request_init["account"][field][subfield] + del request_init["google_ads_link"][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 = resources.Account( + return_value = resources.GoogleAdsLink( name="name_value", - display_name="display_name_value", - region_code="region_code_value", - deleted=True, - gmp_organization="gmp_organization_value", + customer_id="customer_id_value", + can_manage_clients=True, + creator_email_address="creator_email_address_value", ) # Wrap the value into a proper Response obj @@ -93451,24 +99252,23 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.Account.pb(return_value) + return_value = resources.GoogleAdsLink.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_account(request) + response = client.create_google_ads_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Account) + assert isinstance(response, resources.GoogleAdsLink) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.region_code == "region_code_value" - assert response.deleted is True - assert response.gmp_organization == "gmp_organization_value" + assert response.customer_id == "customer_id_value" + assert response.can_manage_clients is True + assert response.creator_email_address == "creator_email_address_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_account_rest_interceptors(null_interceptor): +def test_create_google_ads_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -93482,18 +99282,18 @@ def test_update_account_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_account" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_google_ads_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_account_with_metadata", + "post_create_google_ads_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_account" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_google_ads_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateAccountRequest.pb( - analytics_admin.UpdateAccountRequest() + pb_message = analytics_admin.CreateGoogleAdsLinkRequest.pb( + analytics_admin.CreateGoogleAdsLinkRequest() ) transcode.return_value = { "method": "post", @@ -93505,19 +99305,19 @@ def test_update_account_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.Account.to_json(resources.Account()) + return_value = resources.GoogleAdsLink.to_json(resources.GoogleAdsLink()) req.return_value.content = return_value - request = analytics_admin.UpdateAccountRequest() + request = analytics_admin.CreateGoogleAdsLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Account() - post_with_metadata.return_value = resources.Account(), metadata + post.return_value = resources.GoogleAdsLink() + post_with_metadata.return_value = resources.GoogleAdsLink(), metadata - client.update_account( + client.create_google_ads_link( request, metadata=[ ("key", "val"), @@ -93530,14 +99330,16 @@ def test_update_account_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_provision_account_ticket_rest_bad_request( - request_type=analytics_admin.ProvisionAccountTicketRequest, +def test_update_google_ads_link_rest_bad_request( + request_type=analytics_admin.UpdateGoogleAdsLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "google_ads_link": {"name": "properties/sample1/googleAdsLinks/sample2"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -93552,163 +99354,113 @@ def test_provision_account_ticket_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.provision_account_ticket(request) + client.update_google_ads_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ProvisionAccountTicketRequest, + analytics_admin.UpdateGoogleAdsLinkRequest, dict, ], ) -def test_provision_account_ticket_rest_call_success(request_type): +def test_update_google_ads_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( 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 = analytics_admin.ProvisionAccountTicketResponse( - account_ticket_id="account_ticket_id_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 = analytics_admin.ProvisionAccountTicketResponse.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.provision_account_ticket(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.ProvisionAccountTicketResponse) - assert response.account_ticket_id == "account_ticket_id_value" - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_provision_account_ticket_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_provision_account_ticket" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_provision_account_ticket_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_provision_account_ticket" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.ProvisionAccountTicketRequest.pb( - analytics_admin.ProvisionAccountTicketRequest() - ) - 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 = analytics_admin.ProvisionAccountTicketResponse.to_json( - analytics_admin.ProvisionAccountTicketResponse() - ) - req.return_value.content = return_value - - request = analytics_admin.ProvisionAccountTicketRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = analytics_admin.ProvisionAccountTicketResponse() - post_with_metadata.return_value = ( - analytics_admin.ProvisionAccountTicketResponse(), - metadata, - ) - - client.provision_account_ticket( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) + request_init = { + "google_ads_link": {"name": "properties/sample1/googleAdsLinks/sample2"} + } + request_init["google_ads_link"] = { + "name": "properties/sample1/googleAdsLinks/sample2", + "customer_id": "customer_id_value", + "can_manage_clients": True, + "ads_personalization_enabled": {"value": True}, + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "creator_email_address": "creator_email_address_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 - pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateGoogleAdsLinkRequest.meta.fields[ + "google_ads_link" + ] + 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 = [] -def test_list_account_summaries_rest_bad_request( - request_type=analytics_admin.ListAccountSummariesRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {} - request = request_type(**request_init) + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") - # 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_account_summaries(request) + 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) + ] -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.ListAccountSummariesRequest, - dict, - ], -) -def test_list_account_summaries_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + subfields_not_in_runtime = [] - # send a request that will satisfy transcoding - request_init = {} + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["google_ads_link"].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["google_ads_link"][field])): + del request_init["google_ads_link"][field][i][subfield] + else: + del request_init["google_ads_link"][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 = analytics_admin.ListAccountSummariesResponse( - next_page_token="next_page_token_value", + return_value = resources.GoogleAdsLink( + name="name_value", + customer_id="customer_id_value", + can_manage_clients=True, + creator_email_address="creator_email_address_value", ) # Wrap the value into a proper Response obj @@ -93716,20 +99468,23 @@ def test_list_account_summaries_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAccountSummariesResponse.pb(return_value) + return_value = resources.GoogleAdsLink.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_account_summaries(request) + response = client.update_google_ads_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAccountSummariesPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.GoogleAdsLink) + assert response.name == "name_value" + assert response.customer_id == "customer_id_value" + assert response.can_manage_clients is True + assert response.creator_email_address == "creator_email_address_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_account_summaries_rest_interceptors(null_interceptor): +def test_update_google_ads_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -93743,18 +99498,18 @@ def test_list_account_summaries_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_account_summaries" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_google_ads_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_account_summaries_with_metadata", + "post_update_google_ads_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_account_summaries" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_google_ads_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListAccountSummariesRequest.pb( - analytics_admin.ListAccountSummariesRequest() + pb_message = analytics_admin.UpdateGoogleAdsLinkRequest.pb( + analytics_admin.UpdateGoogleAdsLinkRequest() ) transcode.return_value = { "method": "post", @@ -93766,24 +99521,19 @@ def test_list_account_summaries_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 = analytics_admin.ListAccountSummariesResponse.to_json( - analytics_admin.ListAccountSummariesResponse() - ) + return_value = resources.GoogleAdsLink.to_json(resources.GoogleAdsLink()) req.return_value.content = return_value - request = analytics_admin.ListAccountSummariesRequest() + request = analytics_admin.UpdateGoogleAdsLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListAccountSummariesResponse() - post_with_metadata.return_value = ( - analytics_admin.ListAccountSummariesResponse(), - metadata, - ) + post.return_value = resources.GoogleAdsLink() + post_with_metadata.return_value = resources.GoogleAdsLink(), metadata - client.list_account_summaries( + client.update_google_ads_link( request, metadata=[ ("key", "val"), @@ -93796,12 +99546,14 @@ def test_list_account_summaries_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_property_rest_bad_request(request_type=analytics_admin.GetPropertyRequest): +def test_delete_google_ads_link_rest_bad_request( + request_type=analytics_admin.DeleteGoogleAdsLinkRequest, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1"} + request_init = {"name": "properties/sample1/googleAdsLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -93816,67 +99568,45 @@ def test_get_property_rest_bad_request(request_type=analytics_admin.GetPropertyR response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_property(request) + client.delete_google_ads_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetPropertyRequest, + analytics_admin.DeleteGoogleAdsLinkRequest, dict, ], ) -def test_get_property_rest_call_success(request_type): +def test_delete_google_ads_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1"} + request_init = {"name": "properties/sample1/googleAdsLinks/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 = resources.Property( - name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", - ) + return_value = None # 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.Property.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"} - response = client.get_property(request) + response = client.delete_google_ads_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Property) - assert response.name == "name_value" - assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY - assert response.parent == "parent_value" - assert response.display_name == "display_name_value" - assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE - assert response.time_zone == "time_zone_value" - assert response.currency_code == "currency_code_value" - assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD - assert response.account == "account_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_property_rest_interceptors(null_interceptor): +def test_delete_google_ads_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -93890,18 +99620,11 @@ def test_get_property_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_property" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_property_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_property" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_google_ads_link" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetPropertyRequest.pb( - analytics_admin.GetPropertyRequest() + pb_message = analytics_admin.DeleteGoogleAdsLinkRequest.pb( + analytics_admin.DeleteGoogleAdsLinkRequest() ) transcode.return_value = { "method": "post", @@ -93913,19 +99636,15 @@ def test_get_property_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.Property.to_json(resources.Property()) - req.return_value.content = return_value - request = analytics_admin.GetPropertyRequest() + request = analytics_admin.DeleteGoogleAdsLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Property() - post_with_metadata.return_value = resources.Property(), metadata - client.get_property( + client.delete_google_ads_link( request, metadata=[ ("key", "val"), @@ -93934,18 +99653,16 @@ def test_get_property_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_list_properties_rest_bad_request( - request_type=analytics_admin.ListPropertiesRequest, +def test_list_google_ads_links_rest_bad_request( + request_type=analytics_admin.ListGoogleAdsLinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -93960,29 +99677,29 @@ def test_list_properties_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.list_properties(request) + client.list_google_ads_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListPropertiesRequest, + analytics_admin.ListGoogleAdsLinksRequest, dict, ], ) -def test_list_properties_rest_call_success(request_type): +def test_list_google_ads_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/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 = analytics_admin.ListPropertiesResponse( + return_value = analytics_admin.ListGoogleAdsLinksResponse( next_page_token="next_page_token_value", ) @@ -93991,20 +99708,20 @@ def test_list_properties_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListPropertiesResponse.pb(return_value) + return_value = analytics_admin.ListGoogleAdsLinksResponse.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_properties(request) + response = client.list_google_ads_links(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListPropertiesPager) + assert isinstance(response, pagers.ListGoogleAdsLinksPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_properties_rest_interceptors(null_interceptor): +def test_list_google_ads_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -94018,18 +99735,18 @@ def test_list_properties_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_properties" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_google_ads_links" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_properties_with_metadata", + "post_list_google_ads_links_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_properties" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_google_ads_links" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListPropertiesRequest.pb( - analytics_admin.ListPropertiesRequest() + pb_message = analytics_admin.ListGoogleAdsLinksRequest.pb( + analytics_admin.ListGoogleAdsLinksRequest() ) transcode.return_value = { "method": "post", @@ -94041,24 +99758,24 @@ def test_list_properties_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 = analytics_admin.ListPropertiesResponse.to_json( - analytics_admin.ListPropertiesResponse() + return_value = analytics_admin.ListGoogleAdsLinksResponse.to_json( + analytics_admin.ListGoogleAdsLinksResponse() ) req.return_value.content = return_value - request = analytics_admin.ListPropertiesRequest() + request = analytics_admin.ListGoogleAdsLinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListPropertiesResponse() + post.return_value = analytics_admin.ListGoogleAdsLinksResponse() post_with_metadata.return_value = ( - analytics_admin.ListPropertiesResponse(), + analytics_admin.ListGoogleAdsLinksResponse(), metadata, ) - client.list_properties( + client.list_google_ads_links( request, metadata=[ ("key", "val"), @@ -94071,14 +99788,14 @@ def test_list_properties_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_property_rest_bad_request( - request_type=analytics_admin.CreatePropertyRequest, +def test_get_data_sharing_settings_rest_bad_request( + request_type=analytics_admin.GetDataSharingSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"name": "accounts/sample1/dataSharingSettings"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -94093,120 +99810,35 @@ def test_create_property_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_property(request) + client.get_data_sharing_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreatePropertyRequest, + analytics_admin.GetDataSharingSettingsRequest, dict, ], ) -def test_create_property_rest_call_success(request_type): +def test_get_data_sharing_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} - request_init["property"] = { - "name": "name_value", - "property_type": 1, - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - "parent": "parent_value", - "display_name": "display_name_value", - "industry_category": 1, - "time_zone": "time_zone_value", - "currency_code": "currency_code_value", - "service_level": 1, - "delete_time": {}, - "expire_time": {}, - "account": "account_value", - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreatePropertyRequest.meta.fields["property"] - - 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["property"].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["property"][field])): - del request_init["property"][field][i][subfield] - else: - del request_init["property"][field][subfield] + request_init = {"name": "accounts/sample1/dataSharingSettings"} 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.Property( + return_value = resources.DataSharingSettings( name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", + sharing_with_google_support_enabled=True, + sharing_with_google_assigned_sales_enabled=True, + sharing_with_google_any_sales_enabled=True, + sharing_with_google_products_enabled=True, + sharing_with_others_enabled=True, ) # Wrap the value into a proper Response obj @@ -94214,28 +99846,25 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.Property.pb(return_value) + return_value = resources.DataSharingSettings.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.create_property(request) + response = client.get_data_sharing_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Property) + assert isinstance(response, resources.DataSharingSettings) assert response.name == "name_value" - assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY - assert response.parent == "parent_value" - assert response.display_name == "display_name_value" - assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE - assert response.time_zone == "time_zone_value" - assert response.currency_code == "currency_code_value" - assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD - assert response.account == "account_value" + assert response.sharing_with_google_support_enabled is True + assert response.sharing_with_google_assigned_sales_enabled is True + assert response.sharing_with_google_any_sales_enabled is True + assert response.sharing_with_google_products_enabled is True + assert response.sharing_with_others_enabled is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_property_rest_interceptors(null_interceptor): +def test_get_data_sharing_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -94249,18 +99878,19 @@ def test_create_property_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_property" + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_data_sharing_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_property_with_metadata", + "post_get_data_sharing_settings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_property" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_data_sharing_settings" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreatePropertyRequest.pb( - analytics_admin.CreatePropertyRequest() + pb_message = analytics_admin.GetDataSharingSettingsRequest.pb( + analytics_admin.GetDataSharingSettingsRequest() ) transcode.return_value = { "method": "post", @@ -94272,19 +99902,21 @@ def test_create_property_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.Property.to_json(resources.Property()) + return_value = resources.DataSharingSettings.to_json( + resources.DataSharingSettings() + ) req.return_value.content = return_value - request = analytics_admin.CreatePropertyRequest() + request = analytics_admin.GetDataSharingSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Property() - post_with_metadata.return_value = resources.Property(), metadata + post.return_value = resources.DataSharingSettings() + post_with_metadata.return_value = resources.DataSharingSettings(), metadata - client.create_property( + client.get_data_sharing_settings( request, metadata=[ ("key", "val"), @@ -94297,14 +99929,16 @@ def test_create_property_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_property_rest_bad_request( - request_type=analytics_admin.DeletePropertyRequest, +def test_get_measurement_protocol_secret_rest_bad_request( + request_type=analytics_admin.GetMeasurementProtocolSecretRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -94319,38 +99953,34 @@ def test_delete_property_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_property(request) + client.get_measurement_protocol_secret(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeletePropertyRequest, + analytics_admin.GetMeasurementProtocolSecretRequest, dict, ], ) -def test_delete_property_rest_call_success(request_type): +def test_get_measurement_protocol_secret_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/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 = resources.Property( + return_value = resources.MeasurementProtocolSecret( name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", + secret_value="secret_value_value", ) # Wrap the value into a proper Response obj @@ -94358,28 +99988,22 @@ def test_delete_property_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.Property.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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_property(request) + response = client.get_measurement_protocol_secret(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Property) + assert isinstance(response, resources.MeasurementProtocolSecret) assert response.name == "name_value" - assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY - assert response.parent == "parent_value" assert response.display_name == "display_name_value" - assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE - assert response.time_zone == "time_zone_value" - assert response.currency_code == "currency_code_value" - assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD - assert response.account == "account_value" + assert response.secret_value == "secret_value_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_property_rest_interceptors(null_interceptor): +def test_get_measurement_protocol_secret_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -94393,18 +100017,20 @@ def test_delete_property_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_delete_property" + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_measurement_protocol_secret", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_delete_property_with_metadata", + "post_get_measurement_protocol_secret_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_property" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_get_measurement_protocol_secret", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.DeletePropertyRequest.pb( - analytics_admin.DeletePropertyRequest() + pb_message = analytics_admin.GetMeasurementProtocolSecretRequest.pb( + analytics_admin.GetMeasurementProtocolSecretRequest() ) transcode.return_value = { "method": "post", @@ -94416,19 +100042,24 @@ def test_delete_property_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.Property.to_json(resources.Property()) + return_value = resources.MeasurementProtocolSecret.to_json( + resources.MeasurementProtocolSecret() + ) req.return_value.content = return_value - request = analytics_admin.DeletePropertyRequest() + request = analytics_admin.GetMeasurementProtocolSecretRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Property() - post_with_metadata.return_value = resources.Property(), metadata + post.return_value = resources.MeasurementProtocolSecret() + post_with_metadata.return_value = ( + resources.MeasurementProtocolSecret(), + metadata, + ) - client.delete_property( + client.get_measurement_protocol_secret( request, metadata=[ ("key", "val"), @@ -94441,14 +100072,14 @@ def test_delete_property_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_property_rest_bad_request( - request_type=analytics_admin.UpdatePropertyRequest, +def test_list_measurement_protocol_secrets_rest_bad_request( + request_type=analytics_admin.ListMeasurementProtocolSecretsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"property": {"name": "properties/sample1"}} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -94463,120 +100094,30 @@ def test_update_property_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_property(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.UpdatePropertyRequest, - dict, - ], -) -def test_update_property_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"property": {"name": "properties/sample1"}} - request_init["property"] = { - "name": "properties/sample1", - "property_type": 1, - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - "parent": "parent_value", - "display_name": "display_name_value", - "industry_category": 1, - "time_zone": "time_zone_value", - "currency_code": "currency_code_value", - "service_level": 1, - "delete_time": {}, - "expire_time": {}, - "account": "account_value", - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdatePropertyRequest.meta.fields["property"] - - 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 = [] + client.list_measurement_protocol_secrets(request) - # 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["property"].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.ListMeasurementProtocolSecretsRequest, + dict, + ], +) +def test_list_measurement_protocol_secrets_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["property"][field])): - del request_init["property"][field][i][subfield] - else: - del request_init["property"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"parent": "properties/sample1/dataStreams/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 = resources.Property( - name="name_value", - property_type=resources.PropertyType.PROPERTY_TYPE_ORDINARY, - parent="parent_value", - display_name="display_name_value", - industry_category=resources.IndustryCategory.AUTOMOTIVE, - time_zone="time_zone_value", - currency_code="currency_code_value", - service_level=resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD, - account="account_value", + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -94584,28 +100125,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.Property.pb(return_value) + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse.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_property(request) + response = client.list_measurement_protocol_secrets(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.Property) - assert response.name == "name_value" - assert response.property_type == resources.PropertyType.PROPERTY_TYPE_ORDINARY - assert response.parent == "parent_value" - assert response.display_name == "display_name_value" - assert response.industry_category == resources.IndustryCategory.AUTOMOTIVE - assert response.time_zone == "time_zone_value" - assert response.currency_code == "currency_code_value" - assert response.service_level == resources.ServiceLevel.GOOGLE_ANALYTICS_STANDARD - assert response.account == "account_value" + assert isinstance(response, pagers.ListMeasurementProtocolSecretsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_property_rest_interceptors(null_interceptor): +def test_list_measurement_protocol_secrets_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -94619,18 +100154,20 @@ def test_update_property_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_property" + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_measurement_protocol_secrets", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_property_with_metadata", + "post_list_measurement_protocol_secrets_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_property" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_list_measurement_protocol_secrets", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdatePropertyRequest.pb( - analytics_admin.UpdatePropertyRequest() + pb_message = analytics_admin.ListMeasurementProtocolSecretsRequest.pb( + analytics_admin.ListMeasurementProtocolSecretsRequest() ) transcode.return_value = { "method": "post", @@ -94642,19 +100179,24 @@ def test_update_property_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.Property.to_json(resources.Property()) + return_value = analytics_admin.ListMeasurementProtocolSecretsResponse.to_json( + analytics_admin.ListMeasurementProtocolSecretsResponse() + ) req.return_value.content = return_value - request = analytics_admin.UpdatePropertyRequest() + request = analytics_admin.ListMeasurementProtocolSecretsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.Property() - post_with_metadata.return_value = resources.Property(), metadata + post.return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() + post_with_metadata.return_value = ( + analytics_admin.ListMeasurementProtocolSecretsResponse(), + metadata, + ) - client.update_property( + client.list_measurement_protocol_secrets( request, metadata=[ ("key", "val"), @@ -94667,14 +100209,14 @@ def test_update_property_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_firebase_link_rest_bad_request( - request_type=analytics_admin.CreateFirebaseLinkRequest, +def test_create_measurement_protocol_secret_rest_bad_request( + request_type=analytics_admin.CreateMeasurementProtocolSecretRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -94689,34 +100231,36 @@ def test_create_firebase_link_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_firebase_link(request) + client.create_measurement_protocol_secret(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateFirebaseLinkRequest, + analytics_admin.CreateMeasurementProtocolSecretRequest, dict, ], ) -def test_create_firebase_link_rest_call_success(request_type): +def test_create_measurement_protocol_secret_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["firebase_link"] = { + request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init["measurement_protocol_secret"] = { "name": "name_value", - "project": "project_value", - "create_time": {"seconds": 751, "nanos": 543}, + "display_name": "display_name_value", + "secret_value": "secret_value_value", } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateFirebaseLinkRequest.meta.fields["firebase_link"] + test_field = analytics_admin.CreateMeasurementProtocolSecretRequest.meta.fields[ + "measurement_protocol_secret" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -94744,7 +100288,9 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["firebase_link"].items(): # pragma: NO COVER + for field, value in request_init[ + "measurement_protocol_secret" + ].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -94774,18 +100320,21 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["firebase_link"][field])): - del request_init["firebase_link"][field][i][subfield] + for i in range( + 0, len(request_init["measurement_protocol_secret"][field]) + ): + del request_init["measurement_protocol_secret"][field][i][subfield] else: - del request_init["firebase_link"][field][subfield] + del request_init["measurement_protocol_secret"][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 = resources.FirebaseLink( + return_value = resources.MeasurementProtocolSecret( name="name_value", - project="project_value", + display_name="display_name_value", + secret_value="secret_value_value", ) # Wrap the value into a proper Response obj @@ -94793,21 +100342,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.FirebaseLink.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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.create_firebase_link(request) + response = client.create_measurement_protocol_secret(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.FirebaseLink) + assert isinstance(response, resources.MeasurementProtocolSecret) assert response.name == "name_value" - assert response.project == "project_value" + assert response.display_name == "display_name_value" + assert response.secret_value == "secret_value_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_firebase_link_rest_interceptors(null_interceptor): +def test_create_measurement_protocol_secret_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -94821,18 +100371,20 @@ def test_create_firebase_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_firebase_link" + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_measurement_protocol_secret", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_firebase_link_with_metadata", + "post_create_measurement_protocol_secret_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_firebase_link" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_create_measurement_protocol_secret", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateFirebaseLinkRequest.pb( - analytics_admin.CreateFirebaseLinkRequest() + pb_message = analytics_admin.CreateMeasurementProtocolSecretRequest.pb( + analytics_admin.CreateMeasurementProtocolSecretRequest() ) transcode.return_value = { "method": "post", @@ -94844,19 +100396,24 @@ def test_create_firebase_link_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.FirebaseLink.to_json(resources.FirebaseLink()) + return_value = resources.MeasurementProtocolSecret.to_json( + resources.MeasurementProtocolSecret() + ) req.return_value.content = return_value - request = analytics_admin.CreateFirebaseLinkRequest() + request = analytics_admin.CreateMeasurementProtocolSecretRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.FirebaseLink() - post_with_metadata.return_value = resources.FirebaseLink(), metadata + post.return_value = resources.MeasurementProtocolSecret() + post_with_metadata.return_value = ( + resources.MeasurementProtocolSecret(), + metadata, + ) - client.create_firebase_link( + client.create_measurement_protocol_secret( request, metadata=[ ("key", "val"), @@ -94869,14 +100426,16 @@ def test_create_firebase_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_firebase_link_rest_bad_request( - request_type=analytics_admin.DeleteFirebaseLinkRequest, +def test_delete_measurement_protocol_secret_rest_bad_request( + request_type=analytics_admin.DeleteMeasurementProtocolSecretRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/firebaseLinks/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -94891,23 +100450,25 @@ def test_delete_firebase_link_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_firebase_link(request) + client.delete_measurement_protocol_secret(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteFirebaseLinkRequest, + analytics_admin.DeleteMeasurementProtocolSecretRequest, dict, ], ) -def test_delete_firebase_link_rest_call_success(request_type): +def test_delete_measurement_protocol_secret_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/firebaseLinks/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -94922,14 +100483,14 @@ def test_delete_firebase_link_rest_call_success(request_type): 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_firebase_link(request) + response = client.delete_measurement_protocol_secret(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_firebase_link_rest_interceptors(null_interceptor): +def test_delete_measurement_protocol_secret_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -94943,11 +100504,12 @@ def test_delete_firebase_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_firebase_link" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_delete_measurement_protocol_secret", ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteFirebaseLinkRequest.pb( - analytics_admin.DeleteFirebaseLinkRequest() + pb_message = analytics_admin.DeleteMeasurementProtocolSecretRequest.pb( + analytics_admin.DeleteMeasurementProtocolSecretRequest() ) transcode.return_value = { "method": "post", @@ -94960,14 +100522,14 @@ def test_delete_firebase_link_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.DeleteFirebaseLinkRequest() + request = analytics_admin.DeleteMeasurementProtocolSecretRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_firebase_link( + client.delete_measurement_protocol_secret( request, metadata=[ ("key", "val"), @@ -94978,14 +100540,18 @@ def test_delete_firebase_link_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_list_firebase_links_rest_bad_request( - request_type=analytics_admin.ListFirebaseLinksRequest, +def test_update_measurement_protocol_secret_rest_bad_request( + request_type=analytics_admin.UpdateMeasurementProtocolSecretRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "measurement_protocol_secret": { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95000,30 +100566,114 @@ def test_list_firebase_links_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.list_firebase_links(request) + client.update_measurement_protocol_secret(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListFirebaseLinksRequest, + analytics_admin.UpdateMeasurementProtocolSecretRequest, dict, ], ) -def test_list_firebase_links_rest_call_success(request_type): +def test_update_measurement_protocol_secret_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "measurement_protocol_secret": { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + } + } + request_init["measurement_protocol_secret"] = { + "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3", + "display_name": "display_name_value", + "secret_value": "secret_value_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateMeasurementProtocolSecretRequest.meta.fields[ + "measurement_protocol_secret" + ] + + 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[ + "measurement_protocol_secret" + ].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["measurement_protocol_secret"][field]) + ): + del request_init["measurement_protocol_secret"][field][i][subfield] + else: + del request_init["measurement_protocol_secret"][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 = analytics_admin.ListFirebaseLinksResponse( - next_page_token="next_page_token_value", + return_value = resources.MeasurementProtocolSecret( + name="name_value", + display_name="display_name_value", + secret_value="secret_value_value", ) # Wrap the value into a proper Response obj @@ -95031,20 +100681,22 @@ def test_list_firebase_links_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListFirebaseLinksResponse.pb(return_value) + return_value = resources.MeasurementProtocolSecret.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_firebase_links(request) + response = client.update_measurement_protocol_secret(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListFirebaseLinksPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.MeasurementProtocolSecret) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.secret_value == "secret_value_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_firebase_links_rest_interceptors(null_interceptor): +def test_update_measurement_protocol_secret_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -95058,18 +100710,20 @@ def test_list_firebase_links_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_firebase_links" + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_measurement_protocol_secret", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_firebase_links_with_metadata", + "post_update_measurement_protocol_secret_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_firebase_links" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_update_measurement_protocol_secret", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListFirebaseLinksRequest.pb( - analytics_admin.ListFirebaseLinksRequest() + pb_message = analytics_admin.UpdateMeasurementProtocolSecretRequest.pb( + analytics_admin.UpdateMeasurementProtocolSecretRequest() ) transcode.return_value = { "method": "post", @@ -95081,24 +100735,24 @@ def test_list_firebase_links_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 = analytics_admin.ListFirebaseLinksResponse.to_json( - analytics_admin.ListFirebaseLinksResponse() + return_value = resources.MeasurementProtocolSecret.to_json( + resources.MeasurementProtocolSecret() ) req.return_value.content = return_value - request = analytics_admin.ListFirebaseLinksRequest() + request = analytics_admin.UpdateMeasurementProtocolSecretRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListFirebaseLinksResponse() + post.return_value = resources.MeasurementProtocolSecret() post_with_metadata.return_value = ( - analytics_admin.ListFirebaseLinksResponse(), + resources.MeasurementProtocolSecret(), metadata, ) - client.list_firebase_links( + client.update_measurement_protocol_secret( request, metadata=[ ("key", "val"), @@ -95111,14 +100765,14 @@ def test_list_firebase_links_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_global_site_tag_rest_bad_request( - request_type=analytics_admin.GetGlobalSiteTagRequest, +def test_acknowledge_user_data_collection_rest_bad_request( + request_type=analytics_admin.AcknowledgeUserDataCollectionRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataStreams/sample2/globalSiteTag"} + request_init = {"property": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95133,53 +100787,50 @@ def test_get_global_site_tag_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_global_site_tag(request) + client.acknowledge_user_data_collection(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetGlobalSiteTagRequest, + analytics_admin.AcknowledgeUserDataCollectionRequest, dict, ], ) -def test_get_global_site_tag_rest_call_success(request_type): +def test_acknowledge_user_data_collection_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataStreams/sample2/globalSiteTag"} + request_init = {"property": "properties/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.GlobalSiteTag( - name="name_value", - snippet="snippet_value", - ) + return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() # 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.GlobalSiteTag.pb(return_value) + return_value = analytics_admin.AcknowledgeUserDataCollectionResponse.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_global_site_tag(request) + response = client.acknowledge_user_data_collection(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.GlobalSiteTag) - assert response.name == "name_value" - assert response.snippet == "snippet_value" + assert isinstance(response, analytics_admin.AcknowledgeUserDataCollectionResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_global_site_tag_rest_interceptors(null_interceptor): +def test_acknowledge_user_data_collection_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -95193,18 +100844,20 @@ def test_get_global_site_tag_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_global_site_tag" + transports.AnalyticsAdminServiceRestInterceptor, + "post_acknowledge_user_data_collection", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_global_site_tag_with_metadata", + "post_acknowledge_user_data_collection_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_global_site_tag" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_acknowledge_user_data_collection", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetGlobalSiteTagRequest.pb( - analytics_admin.GetGlobalSiteTagRequest() + pb_message = analytics_admin.AcknowledgeUserDataCollectionRequest.pb( + analytics_admin.AcknowledgeUserDataCollectionRequest() ) transcode.return_value = { "method": "post", @@ -95216,19 +100869,24 @@ def test_get_global_site_tag_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.GlobalSiteTag.to_json(resources.GlobalSiteTag()) + return_value = analytics_admin.AcknowledgeUserDataCollectionResponse.to_json( + analytics_admin.AcknowledgeUserDataCollectionResponse() + ) req.return_value.content = return_value - request = analytics_admin.GetGlobalSiteTagRequest() + request = analytics_admin.AcknowledgeUserDataCollectionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.GlobalSiteTag() - post_with_metadata.return_value = resources.GlobalSiteTag(), metadata + post.return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() + post_with_metadata.return_value = ( + analytics_admin.AcknowledgeUserDataCollectionResponse(), + metadata, + ) - client.get_global_site_tag( + client.acknowledge_user_data_collection( request, metadata=[ ("key", "val"), @@ -95241,14 +100899,16 @@ def test_get_global_site_tag_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_google_ads_link_rest_bad_request( - request_type=analytics_admin.CreateGoogleAdsLinkRequest, +def test_get_sk_ad_network_conversion_value_schema_rest_bad_request( + request_type=analytics_admin.GetSKAdNetworkConversionValueSchemaRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95259,115 +100919,37 @@ def test_create_google_ads_link_rest_bad_request( 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_google_ads_link(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.CreateGoogleAdsLinkRequest, - dict, - ], -) -def test_create_google_ads_link_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["google_ads_link"] = { - "name": "name_value", - "customer_id": "customer_id_value", - "can_manage_clients": True, - "ads_personalization_enabled": {"value": True}, - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - "creator_email_address": "creator_email_address_value", - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateGoogleAdsLinkRequest.meta.fields[ - "google_ads_link" - ] - - 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["google_ads_link"].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, - } - ) + 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_sk_ad_network_conversion_value_schema(request) - # 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["google_ads_link"][field])): - del request_init["google_ads_link"][field][i][subfield] - else: - del request_init["google_ads_link"][field][subfield] + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetSKAdNetworkConversionValueSchemaRequest, + dict, + ], +) +def test_get_sk_ad_network_conversion_value_schema_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/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 = resources.GoogleAdsLink( + return_value = resources.SKAdNetworkConversionValueSchema( name="name_value", - customer_id="customer_id_value", - can_manage_clients=True, - creator_email_address="creator_email_address_value", + apply_conversion_values=True, ) # Wrap the value into a proper Response obj @@ -95375,23 +100957,21 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleAdsLink.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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.create_google_ads_link(request) + response = client.get_sk_ad_network_conversion_value_schema(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.GoogleAdsLink) + assert isinstance(response, resources.SKAdNetworkConversionValueSchema) assert response.name == "name_value" - assert response.customer_id == "customer_id_value" - assert response.can_manage_clients is True - assert response.creator_email_address == "creator_email_address_value" + assert response.apply_conversion_values is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_google_ads_link_rest_interceptors(null_interceptor): +def test_get_sk_ad_network_conversion_value_schema_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -95405,18 +100985,20 @@ def test_create_google_ads_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_google_ads_link" + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_sk_ad_network_conversion_value_schema", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_google_ads_link_with_metadata", + "post_get_sk_ad_network_conversion_value_schema_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_google_ads_link" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_get_sk_ad_network_conversion_value_schema", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateGoogleAdsLinkRequest.pb( - analytics_admin.CreateGoogleAdsLinkRequest() + pb_message = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest.pb( + analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() ) transcode.return_value = { "method": "post", @@ -95428,19 +101010,24 @@ def test_create_google_ads_link_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.GoogleAdsLink.to_json(resources.GoogleAdsLink()) + return_value = resources.SKAdNetworkConversionValueSchema.to_json( + resources.SKAdNetworkConversionValueSchema() + ) req.return_value.content = return_value - request = analytics_admin.CreateGoogleAdsLinkRequest() + request = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.GoogleAdsLink() - post_with_metadata.return_value = resources.GoogleAdsLink(), metadata + post.return_value = resources.SKAdNetworkConversionValueSchema() + post_with_metadata.return_value = ( + resources.SKAdNetworkConversionValueSchema(), + metadata, + ) - client.create_google_ads_link( + client.get_sk_ad_network_conversion_value_schema( request, metadata=[ ("key", "val"), @@ -95453,16 +101040,14 @@ def test_create_google_ads_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_google_ads_link_rest_bad_request( - request_type=analytics_admin.UpdateGoogleAdsLinkRequest, +def test_create_sk_ad_network_conversion_value_schema_rest_bad_request( + request_type=analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "google_ads_link": {"name": "properties/sample1/googleAdsLinks/sample2"} - } + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95477,42 +101062,59 @@ def test_update_google_ads_link_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_google_ads_link(request) + client.create_sk_ad_network_conversion_value_schema(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateGoogleAdsLinkRequest, + analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest, dict, ], ) -def test_update_google_ads_link_rest_call_success(request_type): +def test_create_sk_ad_network_conversion_value_schema_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "google_ads_link": {"name": "properties/sample1/googleAdsLinks/sample2"} - } - request_init["google_ads_link"] = { - "name": "properties/sample1/googleAdsLinks/sample2", - "customer_id": "customer_id_value", - "can_manage_clients": True, - "ads_personalization_enabled": {"value": True}, - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - "creator_email_address": "creator_email_address_value", + request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init["skadnetwork_conversion_value_schema"] = { + "name": "name_value", + "postback_window_one": { + "conversion_values": [ + { + "display_name": "display_name_value", + "fine_value": 1054, + "coarse_value": 1, + "event_mappings": [ + { + "event_name": "event_name_value", + "min_event_count": 1613, + "max_event_count": 1615, + "min_event_value": 0.16010000000000002, + "max_event_value": 0.1603, + } + ], + "lock_enabled": True, + } + ], + "postback_window_settings_enabled": True, + }, + "postback_window_two": {}, + "postback_window_three": {}, + "apply_conversion_values": True, } # 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 = analytics_admin.UpdateGoogleAdsLinkRequest.meta.fields[ - "google_ads_link" - ] + test_field = ( + analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest.meta.fields[ + "skadnetwork_conversion_value_schema" + ] + ) def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -95540,7 +101142,9 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["google_ads_link"].items(): # pragma: NO COVER + for field, value in request_init[ + "skadnetwork_conversion_value_schema" + ].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -95570,20 +101174,22 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["google_ads_link"][field])): - del request_init["google_ads_link"][field][i][subfield] + for i in range( + 0, len(request_init["skadnetwork_conversion_value_schema"][field]) + ): + del request_init["skadnetwork_conversion_value_schema"][field][i][ + subfield + ] else: - del request_init["google_ads_link"][field][subfield] + del request_init["skadnetwork_conversion_value_schema"][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 = resources.GoogleAdsLink( + return_value = resources.SKAdNetworkConversionValueSchema( name="name_value", - customer_id="customer_id_value", - can_manage_clients=True, - creator_email_address="creator_email_address_value", + apply_conversion_values=True, ) # Wrap the value into a proper Response obj @@ -95591,23 +101197,23 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleAdsLink.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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_google_ads_link(request) + response = client.create_sk_ad_network_conversion_value_schema(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.GoogleAdsLink) + assert isinstance(response, resources.SKAdNetworkConversionValueSchema) assert response.name == "name_value" - assert response.customer_id == "customer_id_value" - assert response.can_manage_clients is True - assert response.creator_email_address == "creator_email_address_value" + assert response.apply_conversion_values is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_google_ads_link_rest_interceptors(null_interceptor): +def test_create_sk_ad_network_conversion_value_schema_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -95621,18 +101227,20 @@ def test_update_google_ads_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_google_ads_link" + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_sk_ad_network_conversion_value_schema", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_google_ads_link_with_metadata", + "post_create_sk_ad_network_conversion_value_schema_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_google_ads_link" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_create_sk_ad_network_conversion_value_schema", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateGoogleAdsLinkRequest.pb( - analytics_admin.UpdateGoogleAdsLinkRequest() + pb_message = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest.pb( + analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() ) transcode.return_value = { "method": "post", @@ -95644,19 +101252,24 @@ def test_update_google_ads_link_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.GoogleAdsLink.to_json(resources.GoogleAdsLink()) + return_value = resources.SKAdNetworkConversionValueSchema.to_json( + resources.SKAdNetworkConversionValueSchema() + ) req.return_value.content = return_value - request = analytics_admin.UpdateGoogleAdsLinkRequest() + request = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.GoogleAdsLink() - post_with_metadata.return_value = resources.GoogleAdsLink(), metadata + post.return_value = resources.SKAdNetworkConversionValueSchema() + post_with_metadata.return_value = ( + resources.SKAdNetworkConversionValueSchema(), + metadata, + ) - client.update_google_ads_link( + client.create_sk_ad_network_conversion_value_schema( request, metadata=[ ("key", "val"), @@ -95669,14 +101282,16 @@ def test_update_google_ads_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_google_ads_link_rest_bad_request( - request_type=analytics_admin.DeleteGoogleAdsLinkRequest, +def test_delete_sk_ad_network_conversion_value_schema_rest_bad_request( + request_type=analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/googleAdsLinks/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95691,23 +101306,25 @@ def test_delete_google_ads_link_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_google_ads_link(request) + client.delete_sk_ad_network_conversion_value_schema(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteGoogleAdsLinkRequest, + analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, dict, ], ) -def test_delete_google_ads_link_rest_call_success(request_type): +def test_delete_sk_ad_network_conversion_value_schema_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/googleAdsLinks/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -95722,14 +101339,16 @@ def test_delete_google_ads_link_rest_call_success(request_type): 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_google_ads_link(request) + response = client.delete_sk_ad_network_conversion_value_schema(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_google_ads_link_rest_interceptors(null_interceptor): +def test_delete_sk_ad_network_conversion_value_schema_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -95743,11 +101362,12 @@ def test_delete_google_ads_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_google_ads_link" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_delete_sk_ad_network_conversion_value_schema", ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteGoogleAdsLinkRequest.pb( - analytics_admin.DeleteGoogleAdsLinkRequest() + pb_message = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest.pb( + analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() ) transcode.return_value = { "method": "post", @@ -95760,14 +101380,14 @@ def test_delete_google_ads_link_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.DeleteGoogleAdsLinkRequest() + request = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_google_ads_link( + client.delete_sk_ad_network_conversion_value_schema( request, metadata=[ ("key", "val"), @@ -95778,14 +101398,18 @@ def test_delete_google_ads_link_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_list_google_ads_links_rest_bad_request( - request_type=analytics_admin.ListGoogleAdsLinksRequest, +def test_update_sk_ad_network_conversion_value_schema_rest_bad_request( + request_type=analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "skadnetwork_conversion_value_schema": { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95800,30 +101424,138 @@ def test_list_google_ads_links_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.list_google_ads_links(request) + client.update_sk_ad_network_conversion_value_schema(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListGoogleAdsLinksRequest, + analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest, dict, ], ) -def test_list_google_ads_links_rest_call_success(request_type): +def test_update_sk_ad_network_conversion_value_schema_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "skadnetwork_conversion_value_schema": { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + } + } + request_init["skadnetwork_conversion_value_schema"] = { + "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3", + "postback_window_one": { + "conversion_values": [ + { + "display_name": "display_name_value", + "fine_value": 1054, + "coarse_value": 1, + "event_mappings": [ + { + "event_name": "event_name_value", + "min_event_count": 1613, + "max_event_count": 1615, + "min_event_value": 0.16010000000000002, + "max_event_value": 0.1603, + } + ], + "lock_enabled": True, + } + ], + "postback_window_settings_enabled": True, + }, + "postback_window_two": {}, + "postback_window_three": {}, + "apply_conversion_values": True, + } + # 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 = ( + analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest.meta.fields[ + "skadnetwork_conversion_value_schema" + ] + ) + + 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[ + "skadnetwork_conversion_value_schema" + ].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["skadnetwork_conversion_value_schema"][field]) + ): + del request_init["skadnetwork_conversion_value_schema"][field][i][ + subfield + ] + else: + del request_init["skadnetwork_conversion_value_schema"][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 = analytics_admin.ListGoogleAdsLinksResponse( - next_page_token="next_page_token_value", + return_value = resources.SKAdNetworkConversionValueSchema( + name="name_value", + apply_conversion_values=True, ) # Wrap the value into a proper Response obj @@ -95831,20 +101563,23 @@ def test_list_google_ads_links_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListGoogleAdsLinksResponse.pb(return_value) + return_value = resources.SKAdNetworkConversionValueSchema.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_google_ads_links(request) + response = client.update_sk_ad_network_conversion_value_schema(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListGoogleAdsLinksPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.SKAdNetworkConversionValueSchema) + assert response.name == "name_value" + assert response.apply_conversion_values is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_google_ads_links_rest_interceptors(null_interceptor): +def test_update_sk_ad_network_conversion_value_schema_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -95858,18 +101593,20 @@ def test_list_google_ads_links_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_google_ads_links" + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_sk_ad_network_conversion_value_schema", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_google_ads_links_with_metadata", + "post_update_sk_ad_network_conversion_value_schema_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_google_ads_links" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_update_sk_ad_network_conversion_value_schema", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListGoogleAdsLinksRequest.pb( - analytics_admin.ListGoogleAdsLinksRequest() + pb_message = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest.pb( + analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() ) transcode.return_value = { "method": "post", @@ -95881,24 +101618,24 @@ def test_list_google_ads_links_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 = analytics_admin.ListGoogleAdsLinksResponse.to_json( - analytics_admin.ListGoogleAdsLinksResponse() + return_value = resources.SKAdNetworkConversionValueSchema.to_json( + resources.SKAdNetworkConversionValueSchema() ) req.return_value.content = return_value - request = analytics_admin.ListGoogleAdsLinksRequest() + request = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListGoogleAdsLinksResponse() + post.return_value = resources.SKAdNetworkConversionValueSchema() post_with_metadata.return_value = ( - analytics_admin.ListGoogleAdsLinksResponse(), + resources.SKAdNetworkConversionValueSchema(), metadata, ) - client.list_google_ads_links( + client.update_sk_ad_network_conversion_value_schema( request, metadata=[ ("key", "val"), @@ -95911,14 +101648,14 @@ def test_list_google_ads_links_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_data_sharing_settings_rest_bad_request( - request_type=analytics_admin.GetDataSharingSettingsRequest, +def test_list_sk_ad_network_conversion_value_schemas_rest_bad_request( + request_type=analytics_admin.ListSKAdNetworkConversionValueSchemasRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1/dataSharingSettings"} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -95933,35 +101670,30 @@ def test_get_data_sharing_settings_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_data_sharing_settings(request) + client.list_sk_ad_network_conversion_value_schemas(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetDataSharingSettingsRequest, + analytics_admin.ListSKAdNetworkConversionValueSchemasRequest, dict, ], ) -def test_get_data_sharing_settings_rest_call_success(request_type): +def test_list_sk_ad_network_conversion_value_schemas_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1/dataSharingSettings"} + request_init = {"parent": "properties/sample1/dataStreams/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 = resources.DataSharingSettings( - name="name_value", - sharing_with_google_support_enabled=True, - sharing_with_google_assigned_sales_enabled=True, - sharing_with_google_any_sales_enabled=True, - sharing_with_google_products_enabled=True, - sharing_with_others_enabled=True, + return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -95969,25 +101701,24 @@ def test_get_data_sharing_settings_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataSharingSettings.pb(return_value) + return_value = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.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_data_sharing_settings(request) + response = client.list_sk_ad_network_conversion_value_schemas(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataSharingSettings) - assert response.name == "name_value" - assert response.sharing_with_google_support_enabled is True - assert response.sharing_with_google_assigned_sales_enabled is True - assert response.sharing_with_google_any_sales_enabled is True - assert response.sharing_with_google_products_enabled is True - assert response.sharing_with_others_enabled is True + assert isinstance(response, pagers.ListSKAdNetworkConversionValueSchemasPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_data_sharing_settings_rest_interceptors(null_interceptor): +def test_list_sk_ad_network_conversion_value_schemas_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96002,18 +101733,19 @@ def test_get_data_sharing_settings_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_sharing_settings", + "post_list_sk_ad_network_conversion_value_schemas", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_sharing_settings_with_metadata", + "post_list_sk_ad_network_conversion_value_schemas_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_data_sharing_settings" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_list_sk_ad_network_conversion_value_schemas", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetDataSharingSettingsRequest.pb( - analytics_admin.GetDataSharingSettingsRequest() + pb_message = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest.pb( + analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() ) transcode.return_value = { "method": "post", @@ -96025,21 +101757,28 @@ def test_get_data_sharing_settings_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.DataSharingSettings.to_json( - resources.DataSharingSettings() + return_value = ( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.to_json( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() + ) ) req.return_value.content = return_value - request = analytics_admin.GetDataSharingSettingsRequest() + request = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataSharingSettings() - post_with_metadata.return_value = resources.DataSharingSettings(), metadata + post.return_value = ( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() + ) + post_with_metadata.return_value = ( + analytics_admin.ListSKAdNetworkConversionValueSchemasResponse(), + metadata, + ) - client.get_data_sharing_settings( + client.list_sk_ad_network_conversion_value_schemas( request, metadata=[ ("key", "val"), @@ -96052,16 +101791,14 @@ def test_get_data_sharing_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_measurement_protocol_secret_rest_bad_request( - request_type=analytics_admin.GetMeasurementProtocolSecretRequest, +def test_search_change_history_events_rest_bad_request( + request_type=analytics_admin.SearchChangeHistoryEventsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + request_init = {"account": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -96076,34 +101813,30 @@ def test_get_measurement_protocol_secret_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_measurement_protocol_secret(request) + client.search_change_history_events(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetMeasurementProtocolSecretRequest, + analytics_admin.SearchChangeHistoryEventsRequest, dict, ], ) -def test_get_measurement_protocol_secret_rest_call_success(request_type): +def test_search_change_history_events_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + request_init = {"account": "accounts/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.MeasurementProtocolSecret( - name="name_value", - display_name="display_name_value", - secret_value="secret_value_value", + return_value = analytics_admin.SearchChangeHistoryEventsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -96111,22 +101844,22 @@ def test_get_measurement_protocol_secret_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = analytics_admin.SearchChangeHistoryEventsResponse.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_measurement_protocol_secret(request) + response = client.search_change_history_events(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.MeasurementProtocolSecret) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.secret_value == "secret_value_value" + assert isinstance(response, pagers.SearchChangeHistoryEventsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_measurement_protocol_secret_rest_interceptors(null_interceptor): +def test_search_change_history_events_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96141,19 +101874,19 @@ def test_get_measurement_protocol_secret_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_measurement_protocol_secret", + "post_search_change_history_events", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_measurement_protocol_secret_with_metadata", + "post_search_change_history_events_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_measurement_protocol_secret", + "pre_search_change_history_events", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetMeasurementProtocolSecretRequest.pb( - analytics_admin.GetMeasurementProtocolSecretRequest() + pb_message = analytics_admin.SearchChangeHistoryEventsRequest.pb( + analytics_admin.SearchChangeHistoryEventsRequest() ) transcode.return_value = { "method": "post", @@ -96165,24 +101898,24 @@ def test_get_measurement_protocol_secret_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.MeasurementProtocolSecret.to_json( - resources.MeasurementProtocolSecret() + return_value = analytics_admin.SearchChangeHistoryEventsResponse.to_json( + analytics_admin.SearchChangeHistoryEventsResponse() ) req.return_value.content = return_value - request = analytics_admin.GetMeasurementProtocolSecretRequest() + request = analytics_admin.SearchChangeHistoryEventsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.MeasurementProtocolSecret() + post.return_value = analytics_admin.SearchChangeHistoryEventsResponse() post_with_metadata.return_value = ( - resources.MeasurementProtocolSecret(), + analytics_admin.SearchChangeHistoryEventsResponse(), metadata, ) - client.get_measurement_protocol_secret( + client.search_change_history_events( request, metadata=[ ("key", "val"), @@ -96195,14 +101928,14 @@ def test_get_measurement_protocol_secret_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_measurement_protocol_secrets_rest_bad_request( - request_type=analytics_admin.ListMeasurementProtocolSecretsRequest, +def test_get_google_signals_settings_rest_bad_request( + request_type=analytics_admin.GetGoogleSignalsSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/googleSignalsSettings"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -96217,30 +101950,32 @@ def test_list_measurement_protocol_secrets_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.list_measurement_protocol_secrets(request) + client.get_google_signals_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListMeasurementProtocolSecretsRequest, + analytics_admin.GetGoogleSignalsSettingsRequest, dict, ], ) -def test_list_measurement_protocol_secrets_rest_call_success(request_type): +def test_get_google_signals_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/googleSignalsSettings"} 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 = analytics_admin.ListMeasurementProtocolSecretsResponse( - next_page_token="next_page_token_value", + return_value = resources.GoogleSignalsSettings( + name="name_value", + state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, + consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, ) # Wrap the value into a proper Response obj @@ -96248,22 +101983,25 @@ def test_list_measurement_protocol_secrets_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListMeasurementProtocolSecretsResponse.pb( - return_value - ) + return_value = resources.GoogleSignalsSettings.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_measurement_protocol_secrets(request) + response = client.get_google_signals_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListMeasurementProtocolSecretsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.GoogleSignalsSettings) + assert response.name == "name_value" + assert response.state == resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED + assert ( + response.consent + == resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_measurement_protocol_secrets_rest_interceptors(null_interceptor): +def test_get_google_signals_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96278,19 +102016,19 @@ def test_list_measurement_protocol_secrets_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_measurement_protocol_secrets", + "post_get_google_signals_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_measurement_protocol_secrets_with_metadata", + "post_get_google_signals_settings_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_list_measurement_protocol_secrets", + "pre_get_google_signals_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListMeasurementProtocolSecretsRequest.pb( - analytics_admin.ListMeasurementProtocolSecretsRequest() + pb_message = analytics_admin.GetGoogleSignalsSettingsRequest.pb( + analytics_admin.GetGoogleSignalsSettingsRequest() ) transcode.return_value = { "method": "post", @@ -96302,24 +102040,21 @@ def test_list_measurement_protocol_secrets_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 = analytics_admin.ListMeasurementProtocolSecretsResponse.to_json( - analytics_admin.ListMeasurementProtocolSecretsResponse() + return_value = resources.GoogleSignalsSettings.to_json( + resources.GoogleSignalsSettings() ) req.return_value.content = return_value - request = analytics_admin.ListMeasurementProtocolSecretsRequest() + request = analytics_admin.GetGoogleSignalsSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListMeasurementProtocolSecretsResponse() - post_with_metadata.return_value = ( - analytics_admin.ListMeasurementProtocolSecretsResponse(), - metadata, - ) + post.return_value = resources.GoogleSignalsSettings() + post_with_metadata.return_value = resources.GoogleSignalsSettings(), metadata - client.list_measurement_protocol_secrets( + client.get_google_signals_settings( request, metadata=[ ("key", "val"), @@ -96332,14 +102067,16 @@ def test_list_measurement_protocol_secrets_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_measurement_protocol_secret_rest_bad_request( - request_type=analytics_admin.CreateMeasurementProtocolSecretRequest, +def test_update_google_signals_settings_rest_bad_request( + request_type=analytics_admin.UpdateGoogleSignalsSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = { + "google_signals_settings": {"name": "properties/sample1/googleSignalsSettings"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -96354,35 +102091,37 @@ def test_create_measurement_protocol_secret_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_measurement_protocol_secret(request) + client.update_google_signals_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateMeasurementProtocolSecretRequest, + analytics_admin.UpdateGoogleSignalsSettingsRequest, dict, ], ) -def test_create_measurement_protocol_secret_rest_call_success(request_type): +def test_update_google_signals_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} - request_init["measurement_protocol_secret"] = { - "name": "name_value", - "display_name": "display_name_value", - "secret_value": "secret_value_value", + request_init = { + "google_signals_settings": {"name": "properties/sample1/googleSignalsSettings"} + } + request_init["google_signals_settings"] = { + "name": "properties/sample1/googleSignalsSettings", + "state": 1, + "consent": 2, } # 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 = analytics_admin.CreateMeasurementProtocolSecretRequest.meta.fields[ - "measurement_protocol_secret" + test_field = analytics_admin.UpdateGoogleSignalsSettingsRequest.meta.fields[ + "google_signals_settings" ] def get_message_fields(field): @@ -96412,7 +102151,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime for field, value in request_init[ - "measurement_protocol_secret" + "google_signals_settings" ].items(): # pragma: NO COVER result = None is_repeated = False @@ -96443,21 +102182,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range( - 0, len(request_init["measurement_protocol_secret"][field]) - ): - del request_init["measurement_protocol_secret"][field][i][subfield] + for i in range(0, len(request_init["google_signals_settings"][field])): + del request_init["google_signals_settings"][field][i][subfield] else: - del request_init["measurement_protocol_secret"][field][subfield] + del request_init["google_signals_settings"][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 = resources.MeasurementProtocolSecret( + return_value = resources.GoogleSignalsSettings( name="name_value", - display_name="display_name_value", - secret_value="secret_value_value", + state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, + consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, ) # Wrap the value into a proper Response obj @@ -96465,22 +102202,25 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = resources.GoogleSignalsSettings.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.create_measurement_protocol_secret(request) + response = client.update_google_signals_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.MeasurementProtocolSecret) + assert isinstance(response, resources.GoogleSignalsSettings) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.secret_value == "secret_value_value" + assert response.state == resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED + assert ( + response.consent + == resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_measurement_protocol_secret_rest_interceptors(null_interceptor): +def test_update_google_signals_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96495,19 +102235,19 @@ def test_create_measurement_protocol_secret_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_measurement_protocol_secret", + "post_update_google_signals_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_measurement_protocol_secret_with_metadata", + "post_update_google_signals_settings_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_create_measurement_protocol_secret", + "pre_update_google_signals_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateMeasurementProtocolSecretRequest.pb( - analytics_admin.CreateMeasurementProtocolSecretRequest() + pb_message = analytics_admin.UpdateGoogleSignalsSettingsRequest.pb( + analytics_admin.UpdateGoogleSignalsSettingsRequest() ) transcode.return_value = { "method": "post", @@ -96519,24 +102259,21 @@ def test_create_measurement_protocol_secret_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.MeasurementProtocolSecret.to_json( - resources.MeasurementProtocolSecret() + return_value = resources.GoogleSignalsSettings.to_json( + resources.GoogleSignalsSettings() ) req.return_value.content = return_value - request = analytics_admin.CreateMeasurementProtocolSecretRequest() + request = analytics_admin.UpdateGoogleSignalsSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.MeasurementProtocolSecret() - post_with_metadata.return_value = ( - resources.MeasurementProtocolSecret(), - metadata, - ) + post.return_value = resources.GoogleSignalsSettings() + post_with_metadata.return_value = resources.GoogleSignalsSettings(), metadata - client.create_measurement_protocol_secret( + client.update_google_signals_settings( request, metadata=[ ("key", "val"), @@ -96549,16 +102286,14 @@ def test_create_measurement_protocol_secret_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_measurement_protocol_secret_rest_bad_request( - request_type=analytics_admin.DeleteMeasurementProtocolSecretRequest, +def test_create_conversion_event_rest_bad_request( + request_type=analytics_admin.CreateConversionEventRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -96573,47 +102308,143 @@ def test_delete_measurement_protocol_secret_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_measurement_protocol_secret(request) + client.create_conversion_event(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteMeasurementProtocolSecretRequest, + analytics_admin.CreateConversionEventRequest, dict, ], ) -def test_delete_measurement_protocol_secret_rest_call_success(request_type): +def test_create_conversion_event_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" + request_init = {"parent": "properties/sample1"} + request_init["conversion_event"] = { + "name": "name_value", + "event_name": "event_name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "deletable": True, + "custom": True, + "counting_method": 1, + "default_conversion_value": { + "value": 0.541, + "currency_code": "currency_code_value", + }, } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.CreateConversionEventRequest.meta.fields[ + "conversion_event" + ] + + 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["conversion_event"].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["conversion_event"][field])): + del request_init["conversion_event"][field][i][subfield] + else: + del request_init["conversion_event"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.ConversionEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.ConversionEvent.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_measurement_protocol_secret(request) + response = client.create_conversion_event(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.ConversionEvent) + assert response.name == "name_value" + assert response.event_name == "event_name_value" + assert response.deletable is True + assert response.custom is True + assert ( + response.counting_method + == resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_measurement_protocol_secret_rest_interceptors(null_interceptor): +def test_create_conversion_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96627,12 +102458,18 @@ def test_delete_measurement_protocol_secret_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "post_create_conversion_event" + ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_delete_measurement_protocol_secret", + "post_create_conversion_event_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_conversion_event" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteMeasurementProtocolSecretRequest.pb( - analytics_admin.DeleteMeasurementProtocolSecretRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.CreateConversionEventRequest.pb( + analytics_admin.CreateConversionEventRequest() ) transcode.return_value = { "method": "post", @@ -96644,15 +102481,19 @@ def test_delete_measurement_protocol_secret_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.ConversionEvent.to_json(resources.ConversionEvent()) + req.return_value.content = return_value - request = analytics_admin.DeleteMeasurementProtocolSecretRequest() + request = analytics_admin.CreateConversionEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.ConversionEvent() + post_with_metadata.return_value = resources.ConversionEvent(), metadata - client.delete_measurement_protocol_secret( + client.create_conversion_event( request, metadata=[ ("key", "val"), @@ -96661,19 +102502,19 @@ def test_delete_measurement_protocol_secret_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_update_measurement_protocol_secret_rest_bad_request( - request_type=analytics_admin.UpdateMeasurementProtocolSecretRequest, +def test_update_conversion_event_rest_bad_request( + request_type=analytics_admin.UpdateConversionEventRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "measurement_protocol_secret": { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + "conversion_event": {"name": "properties/sample1/conversionEvents/sample2"} } request = request_type(**request_init) @@ -96689,39 +102530,44 @@ def test_update_measurement_protocol_secret_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_measurement_protocol_secret(request) + client.update_conversion_event(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateMeasurementProtocolSecretRequest, + analytics_admin.UpdateConversionEventRequest, dict, ], ) -def test_update_measurement_protocol_secret_rest_call_success(request_type): +def test_update_conversion_event_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "measurement_protocol_secret": { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3" - } + "conversion_event": {"name": "properties/sample1/conversionEvents/sample2"} } - request_init["measurement_protocol_secret"] = { - "name": "properties/sample1/dataStreams/sample2/measurementProtocolSecrets/sample3", - "display_name": "display_name_value", - "secret_value": "secret_value_value", + request_init["conversion_event"] = { + "name": "properties/sample1/conversionEvents/sample2", + "event_name": "event_name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "deletable": True, + "custom": True, + "counting_method": 1, + "default_conversion_value": { + "value": 0.541, + "currency_code": "currency_code_value", + }, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateMeasurementProtocolSecretRequest.meta.fields[ - "measurement_protocol_secret" + test_field = analytics_admin.UpdateConversionEventRequest.meta.fields[ + "conversion_event" ] def get_message_fields(field): @@ -96750,9 +102596,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init[ - "measurement_protocol_secret" - ].items(): # pragma: NO COVER + for field, value in request_init["conversion_event"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -96782,21 +102626,21 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range( - 0, len(request_init["measurement_protocol_secret"][field]) - ): - del request_init["measurement_protocol_secret"][field][i][subfield] + for i in range(0, len(request_init["conversion_event"][field])): + del request_init["conversion_event"][field][i][subfield] else: - del request_init["measurement_protocol_secret"][field][subfield] + del request_init["conversion_event"][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 = resources.MeasurementProtocolSecret( + return_value = resources.ConversionEvent( name="name_value", - display_name="display_name_value", - secret_value="secret_value_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, ) # Wrap the value into a proper Response obj @@ -96804,22 +102648,166 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.MeasurementProtocolSecret.pb(return_value) + return_value = resources.ConversionEvent.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_conversion_event(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.ConversionEvent) + assert response.name == "name_value" + assert response.event_name == "event_name_value" + assert response.deletable is True + assert response.custom is True + assert ( + response.counting_method + == resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_conversion_event_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_update_conversion_event" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_conversion_event_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_conversion_event" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdateConversionEventRequest.pb( + analytics_admin.UpdateConversionEventRequest() + ) + 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.ConversionEvent.to_json(resources.ConversionEvent()) + req.return_value.content = return_value + + request = analytics_admin.UpdateConversionEventRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.ConversionEvent() + post_with_metadata.return_value = resources.ConversionEvent(), metadata + + client.update_conversion_event( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_conversion_event_rest_bad_request( + request_type=analytics_admin.GetConversionEventRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "properties/sample1/conversionEvents/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.get_conversion_event(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetConversionEventRequest, + dict, + ], +) +def test_get_conversion_event_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "properties/sample1/conversionEvents/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 = resources.ConversionEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + ) + + # 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.ConversionEvent.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_measurement_protocol_secret(request) + response = client.get_conversion_event(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.MeasurementProtocolSecret) + assert isinstance(response, resources.ConversionEvent) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.secret_value == "secret_value_value" + assert response.event_name == "event_name_value" + assert response.deletable is True + assert response.custom is True + assert ( + response.counting_method + == resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_measurement_protocol_secret_rest_interceptors(null_interceptor): +def test_get_conversion_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96833,20 +102821,18 @@ def test_update_measurement_protocol_secret_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_measurement_protocol_secret", + transports.AnalyticsAdminServiceRestInterceptor, "post_get_conversion_event" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_measurement_protocol_secret_with_metadata", + "post_get_conversion_event_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_measurement_protocol_secret", + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_conversion_event" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateMeasurementProtocolSecretRequest.pb( - analytics_admin.UpdateMeasurementProtocolSecretRequest() + pb_message = analytics_admin.GetConversionEventRequest.pb( + analytics_admin.GetConversionEventRequest() ) transcode.return_value = { "method": "post", @@ -96858,24 +102844,19 @@ def test_update_measurement_protocol_secret_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.MeasurementProtocolSecret.to_json( - resources.MeasurementProtocolSecret() - ) + return_value = resources.ConversionEvent.to_json(resources.ConversionEvent()) req.return_value.content = return_value - request = analytics_admin.UpdateMeasurementProtocolSecretRequest() + request = analytics_admin.GetConversionEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.MeasurementProtocolSecret() - post_with_metadata.return_value = ( - resources.MeasurementProtocolSecret(), - metadata, - ) + post.return_value = resources.ConversionEvent() + post_with_metadata.return_value = resources.ConversionEvent(), metadata - client.update_measurement_protocol_secret( + client.get_conversion_event( request, metadata=[ ("key", "val"), @@ -96888,14 +102869,14 @@ def test_update_measurement_protocol_secret_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_acknowledge_user_data_collection_rest_bad_request( - request_type=analytics_admin.AcknowledgeUserDataCollectionRequest, +def test_delete_conversion_event_rest_bad_request( + request_type=analytics_admin.DeleteConversionEventRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"property": "properties/sample1"} + request_init = {"name": "properties/sample1/conversionEvents/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -96910,50 +102891,45 @@ def test_acknowledge_user_data_collection_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.acknowledge_user_data_collection(request) + client.delete_conversion_event(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.AcknowledgeUserDataCollectionRequest, + analytics_admin.DeleteConversionEventRequest, dict, ], ) -def test_acknowledge_user_data_collection_rest_call_success(request_type): +def test_delete_conversion_event_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"property": "properties/sample1"} + request_init = {"name": "properties/sample1/conversionEvents/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 = analytics_admin.AcknowledgeUserDataCollectionResponse() + return_value = None # 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 = analytics_admin.AcknowledgeUserDataCollectionResponse.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"} - response = client.acknowledge_user_data_collection(request) + response = client.delete_conversion_event(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.AcknowledgeUserDataCollectionResponse) + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_acknowledge_user_data_collection_rest_interceptors(null_interceptor): +def test_delete_conversion_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -96967,20 +102943,11 @@ def test_acknowledge_user_data_collection_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_acknowledge_user_data_collection", - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_acknowledge_user_data_collection_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_acknowledge_user_data_collection", + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_conversion_event" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.AcknowledgeUserDataCollectionRequest.pb( - analytics_admin.AcknowledgeUserDataCollectionRequest() + pb_message = analytics_admin.DeleteConversionEventRequest.pb( + analytics_admin.DeleteConversionEventRequest() ) transcode.return_value = { "method": "post", @@ -96992,24 +102959,15 @@ def test_acknowledge_user_data_collection_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 = analytics_admin.AcknowledgeUserDataCollectionResponse.to_json( - analytics_admin.AcknowledgeUserDataCollectionResponse() - ) - req.return_value.content = return_value - request = analytics_admin.AcknowledgeUserDataCollectionRequest() + request = analytics_admin.DeleteConversionEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.AcknowledgeUserDataCollectionResponse() - post_with_metadata.return_value = ( - analytics_admin.AcknowledgeUserDataCollectionResponse(), - metadata, - ) - client.acknowledge_user_data_collection( + client.delete_conversion_event( request, metadata=[ ("key", "val"), @@ -97018,20 +102976,16 @@ def test_acknowledge_user_data_collection_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_get_sk_ad_network_conversion_value_schema_rest_bad_request( - request_type=analytics_admin.GetSKAdNetworkConversionValueSchemaRequest, +def test_list_conversion_events_rest_bad_request( + request_type=analytics_admin.ListConversionEventsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -97046,33 +103000,30 @@ def test_get_sk_ad_network_conversion_value_schema_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_sk_ad_network_conversion_value_schema(request) + client.list_conversion_events(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetSKAdNetworkConversionValueSchemaRequest, + analytics_admin.ListConversionEventsRequest, dict, ], ) -def test_get_sk_ad_network_conversion_value_schema_rest_call_success(request_type): +def test_list_conversion_events_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } + request_init = {"parent": "properties/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.SKAdNetworkConversionValueSchema( - name="name_value", - apply_conversion_values=True, + return_value = analytics_admin.ListConversionEventsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -97080,21 +103031,20 @@ def test_get_sk_ad_network_conversion_value_schema_rest_call_success(request_typ response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = analytics_admin.ListConversionEventsResponse.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_sk_ad_network_conversion_value_schema(request) + response = client.list_conversion_events(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.SKAdNetworkConversionValueSchema) - assert response.name == "name_value" - assert response.apply_conversion_values is True + assert isinstance(response, pagers.ListConversionEventsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_sk_ad_network_conversion_value_schema_rest_interceptors(null_interceptor): +def test_list_conversion_events_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -97108,20 +103058,18 @@ def test_get_sk_ad_network_conversion_value_schema_rest_interceptors(null_interc ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_sk_ad_network_conversion_value_schema", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_conversion_events" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_sk_ad_network_conversion_value_schema_with_metadata", + "post_list_conversion_events_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_sk_ad_network_conversion_value_schema", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_conversion_events" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest.pb( - analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() + pb_message = analytics_admin.ListConversionEventsRequest.pb( + analytics_admin.ListConversionEventsRequest() ) transcode.return_value = { "method": "post", @@ -97133,24 +103081,24 @@ def test_get_sk_ad_network_conversion_value_schema_rest_interceptors(null_interc 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.SKAdNetworkConversionValueSchema.to_json( - resources.SKAdNetworkConversionValueSchema() + return_value = analytics_admin.ListConversionEventsResponse.to_json( + analytics_admin.ListConversionEventsResponse() ) req.return_value.content = return_value - request = analytics_admin.GetSKAdNetworkConversionValueSchemaRequest() + request = analytics_admin.ListConversionEventsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.SKAdNetworkConversionValueSchema() + post.return_value = analytics_admin.ListConversionEventsResponse() post_with_metadata.return_value = ( - resources.SKAdNetworkConversionValueSchema(), + analytics_admin.ListConversionEventsResponse(), metadata, ) - client.get_sk_ad_network_conversion_value_schema( + client.list_conversion_events( request, metadata=[ ("key", "val"), @@ -97163,14 +103111,14 @@ def test_get_sk_ad_network_conversion_value_schema_rest_interceptors(null_interc post_with_metadata.assert_called_once() -def test_create_sk_ad_network_conversion_value_schema_rest_bad_request( - request_type=analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest, +def test_create_key_event_rest_bad_request( + request_type=analytics_admin.CreateKeyEventRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -97185,59 +103133,41 @@ def test_create_sk_ad_network_conversion_value_schema_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_sk_ad_network_conversion_value_schema(request) + client.create_key_event(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest, + analytics_admin.CreateKeyEventRequest, dict, ], ) -def test_create_sk_ad_network_conversion_value_schema_rest_call_success(request_type): +def test_create_key_event_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} - request_init["skadnetwork_conversion_value_schema"] = { + request_init = {"parent": "properties/sample1"} + request_init["key_event"] = { "name": "name_value", - "postback_window_one": { - "conversion_values": [ - { - "display_name": "display_name_value", - "fine_value": 1054, - "coarse_value": 1, - "event_mappings": [ - { - "event_name": "event_name_value", - "min_event_count": 1613, - "max_event_count": 1615, - "min_event_value": 0.16010000000000002, - "max_event_value": 0.1603, - } - ], - "lock_enabled": True, - } - ], - "postback_window_settings_enabled": True, + "event_name": "event_name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "deletable": True, + "custom": True, + "counting_method": 1, + "default_value": { + "numeric_value": 0.1391, + "currency_code": "currency_code_value", }, - "postback_window_two": {}, - "postback_window_three": {}, - "apply_conversion_values": True, } # 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 = ( - analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest.meta.fields[ - "skadnetwork_conversion_value_schema" - ] - ) + test_field = analytics_admin.CreateKeyEventRequest.meta.fields["key_event"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -97265,9 +103195,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init[ - "skadnetwork_conversion_value_schema" - ].items(): # pragma: NO COVER + for field, value in request_init["key_event"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -97297,22 +103225,21 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range( - 0, len(request_init["skadnetwork_conversion_value_schema"][field]) - ): - del request_init["skadnetwork_conversion_value_schema"][field][i][ - subfield - ] + for i in range(0, len(request_init["key_event"][field])): + del request_init["key_event"][field][i][subfield] else: - del request_init["skadnetwork_conversion_value_schema"][field][subfield] + del request_init["key_event"][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 = resources.SKAdNetworkConversionValueSchema( + return_value = resources.KeyEvent( name="name_value", - apply_conversion_values=True, + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, ) # Wrap the value into a proper Response obj @@ -97320,23 +103247,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = resources.KeyEvent.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.create_sk_ad_network_conversion_value_schema(request) + response = client.create_key_event(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.SKAdNetworkConversionValueSchema) + assert isinstance(response, resources.KeyEvent) assert response.name == "name_value" - assert response.apply_conversion_values is True + assert response.event_name == "event_name_value" + assert response.deletable is True + assert response.custom is True + assert response.counting_method == resources.KeyEvent.CountingMethod.ONCE_PER_EVENT @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_sk_ad_network_conversion_value_schema_rest_interceptors( - null_interceptor, -): +def test_create_key_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -97350,20 +103278,18 @@ def test_create_sk_ad_network_conversion_value_schema_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_sk_ad_network_conversion_value_schema", + transports.AnalyticsAdminServiceRestInterceptor, "post_create_key_event" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_sk_ad_network_conversion_value_schema_with_metadata", + "post_create_key_event_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_create_sk_ad_network_conversion_value_schema", + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_key_event" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest.pb( - analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() + pb_message = analytics_admin.CreateKeyEventRequest.pb( + analytics_admin.CreateKeyEventRequest() ) transcode.return_value = { "method": "post", @@ -97375,24 +103301,19 @@ def test_create_sk_ad_network_conversion_value_schema_rest_interceptors( 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.SKAdNetworkConversionValueSchema.to_json( - resources.SKAdNetworkConversionValueSchema() - ) + return_value = resources.KeyEvent.to_json(resources.KeyEvent()) req.return_value.content = return_value - request = analytics_admin.CreateSKAdNetworkConversionValueSchemaRequest() + request = analytics_admin.CreateKeyEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.SKAdNetworkConversionValueSchema() - post_with_metadata.return_value = ( - resources.SKAdNetworkConversionValueSchema(), - metadata, - ) + post.return_value = resources.KeyEvent() + post_with_metadata.return_value = resources.KeyEvent(), metadata - client.create_sk_ad_network_conversion_value_schema( + client.create_key_event( request, metadata=[ ("key", "val"), @@ -97405,16 +103326,14 @@ def test_create_sk_ad_network_conversion_value_schema_rest_interceptors( post_with_metadata.assert_called_once() -def test_delete_sk_ad_network_conversion_value_schema_rest_bad_request( - request_type=analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, +def test_update_key_event_rest_bad_request( + request_type=analytics_admin.UpdateKeyEventRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } + request_init = {"key_event": {"name": "properties/sample1/keyEvents/sample2"}} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -97429,49 +103348,138 @@ def test_delete_sk_ad_network_conversion_value_schema_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_sk_ad_network_conversion_value_schema(request) + client.update_key_event(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest, + analytics_admin.UpdateKeyEventRequest, dict, ], ) -def test_delete_sk_ad_network_conversion_value_schema_rest_call_success(request_type): +def test_update_key_event_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" + request_init = {"key_event": {"name": "properties/sample1/keyEvents/sample2"}} + request_init["key_event"] = { + "name": "properties/sample1/keyEvents/sample2", + "event_name": "event_name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "deletable": True, + "custom": True, + "counting_method": 1, + "default_value": { + "numeric_value": 0.1391, + "currency_code": "currency_code_value", + }, } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateKeyEventRequest.meta.fields["key_event"] + + 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["key_event"].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["key_event"][field])): + del request_init["key_event"][field][i][subfield] + else: + del request_init["key_event"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.KeyEvent( + name="name_value", + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.KeyEvent.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_sk_ad_network_conversion_value_schema(request) + response = client.update_key_event(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.KeyEvent) + assert response.name == "name_value" + assert response.event_name == "event_name_value" + assert response.deletable is True + assert response.custom is True + assert response.counting_method == resources.KeyEvent.CountingMethod.ONCE_PER_EVENT @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_sk_ad_network_conversion_value_schema_rest_interceptors( - null_interceptor, -): +def test_update_key_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -97485,12 +103493,18 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "post_update_key_event" + ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_delete_sk_ad_network_conversion_value_schema", + "post_update_key_event_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_key_event" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest.pb( - analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdateKeyEventRequest.pb( + analytics_admin.UpdateKeyEventRequest() ) transcode.return_value = { "method": "post", @@ -97502,15 +103516,19 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_interceptors( 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.KeyEvent.to_json(resources.KeyEvent()) + req.return_value.content = return_value - request = analytics_admin.DeleteSKAdNetworkConversionValueSchemaRequest() + request = analytics_admin.UpdateKeyEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.KeyEvent() + post_with_metadata.return_value = resources.KeyEvent(), metadata - client.delete_sk_ad_network_conversion_value_schema( + client.update_key_event( request, metadata=[ ("key", "val"), @@ -97519,166 +103537,60 @@ def test_delete_sk_ad_network_conversion_value_schema_rest_interceptors( ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_update_sk_ad_network_conversion_value_schema_rest_bad_request( - request_type=analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = { - "skadnetwork_conversion_value_schema": { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/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_sk_ad_network_conversion_value_schema(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest, - dict, - ], -) -def test_update_sk_ad_network_conversion_value_schema_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = { - "skadnetwork_conversion_value_schema": { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3" - } - } - request_init["skadnetwork_conversion_value_schema"] = { - "name": "properties/sample1/dataStreams/sample2/sKAdNetworkConversionValueSchema/sample3", - "postback_window_one": { - "conversion_values": [ - { - "display_name": "display_name_value", - "fine_value": 1054, - "coarse_value": 1, - "event_mappings": [ - { - "event_name": "event_name_value", - "min_event_count": 1613, - "max_event_count": 1615, - "min_event_value": 0.16010000000000002, - "max_event_value": 0.1603, - } - ], - "lock_enabled": True, - } - ], - "postback_window_settings_enabled": True, - }, - "postback_window_two": {}, - "postback_window_three": {}, - "apply_conversion_values": True, - } - # 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 = ( - analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest.meta.fields[ - "skadnetwork_conversion_value_schema" - ] - ) - - 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) - ] +def test_get_key_event_rest_bad_request( + request_type=analytics_admin.GetKeyEventRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "properties/sample1/keyEvents/sample2"} + request = request_type(**request_init) - subfields_not_in_runtime = [] + # 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_key_event(request) - # 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[ - "skadnetwork_conversion_value_schema" - ].items(): # pragma: NO COVER - result = None - is_repeated = False - # For repeated fields - if isinstance(value, list) and len(value): - is_repeated = True - result = value[0] - # For fields where the type is another message - if isinstance(value, dict): - result = value - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetKeyEventRequest, + dict, + ], +) +def test_get_key_event_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range( - 0, len(request_init["skadnetwork_conversion_value_schema"][field]) - ): - del request_init["skadnetwork_conversion_value_schema"][field][i][ - subfield - ] - else: - del request_init["skadnetwork_conversion_value_schema"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"name": "properties/sample1/keyEvents/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 = resources.SKAdNetworkConversionValueSchema( + return_value = resources.KeyEvent( name="name_value", - apply_conversion_values=True, + event_name="event_name_value", + deletable=True, + custom=True, + counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, ) # Wrap the value into a proper Response obj @@ -97686,23 +103598,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SKAdNetworkConversionValueSchema.pb(return_value) + return_value = resources.KeyEvent.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_sk_ad_network_conversion_value_schema(request) + response = client.get_key_event(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.SKAdNetworkConversionValueSchema) + assert isinstance(response, resources.KeyEvent) assert response.name == "name_value" - assert response.apply_conversion_values is True + assert response.event_name == "event_name_value" + assert response.deletable is True + assert response.custom is True + assert response.counting_method == resources.KeyEvent.CountingMethod.ONCE_PER_EVENT @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_sk_ad_network_conversion_value_schema_rest_interceptors( - null_interceptor, -): +def test_get_key_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -97716,20 +103629,18 @@ def test_update_sk_ad_network_conversion_value_schema_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_sk_ad_network_conversion_value_schema", + transports.AnalyticsAdminServiceRestInterceptor, "post_get_key_event" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_sk_ad_network_conversion_value_schema_with_metadata", + "post_get_key_event_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_sk_ad_network_conversion_value_schema", + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_key_event" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest.pb( - analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() + pb_message = analytics_admin.GetKeyEventRequest.pb( + analytics_admin.GetKeyEventRequest() ) transcode.return_value = { "method": "post", @@ -97741,24 +103652,19 @@ def test_update_sk_ad_network_conversion_value_schema_rest_interceptors( 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.SKAdNetworkConversionValueSchema.to_json( - resources.SKAdNetworkConversionValueSchema() - ) + return_value = resources.KeyEvent.to_json(resources.KeyEvent()) req.return_value.content = return_value - request = analytics_admin.UpdateSKAdNetworkConversionValueSchemaRequest() + request = analytics_admin.GetKeyEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.SKAdNetworkConversionValueSchema() - post_with_metadata.return_value = ( - resources.SKAdNetworkConversionValueSchema(), - metadata, - ) + post.return_value = resources.KeyEvent() + post_with_metadata.return_value = resources.KeyEvent(), metadata - client.update_sk_ad_network_conversion_value_schema( + client.get_key_event( request, metadata=[ ("key", "val"), @@ -97771,14 +103677,14 @@ def test_update_sk_ad_network_conversion_value_schema_rest_interceptors( post_with_metadata.assert_called_once() -def test_list_sk_ad_network_conversion_value_schemas_rest_bad_request( - request_type=analytics_admin.ListSKAdNetworkConversionValueSchemasRequest, +def test_delete_key_event_rest_bad_request( + request_type=analytics_admin.DeleteKeyEventRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/keyEvents/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -97793,55 +103699,45 @@ def test_list_sk_ad_network_conversion_value_schemas_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.list_sk_ad_network_conversion_value_schemas(request) + client.delete_key_event(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListSKAdNetworkConversionValueSchemasRequest, + analytics_admin.DeleteKeyEventRequest, dict, ], ) -def test_list_sk_ad_network_conversion_value_schemas_rest_call_success(request_type): +def test_delete_key_event_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/keyEvents/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 = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse( - next_page_token="next_page_token_value", - ) + return_value = None # 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 = analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.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"} - response = client.list_sk_ad_network_conversion_value_schemas(request) + response = client.delete_key_event(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListSKAdNetworkConversionValueSchemasPager) - assert response.next_page_token == "next_page_token_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_sk_ad_network_conversion_value_schemas_rest_interceptors( - null_interceptor, -): +def test_delete_key_event_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -97855,20 +103751,11 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_list_sk_ad_network_conversion_value_schemas", - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_list_sk_ad_network_conversion_value_schemas_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_list_sk_ad_network_conversion_value_schemas", + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_key_event" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest.pb( - analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() + pb_message = analytics_admin.DeleteKeyEventRequest.pb( + analytics_admin.DeleteKeyEventRequest() ) transcode.return_value = { "method": "post", @@ -97880,28 +103767,15 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_interceptors( 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 = ( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse.to_json( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() - ) - ) - req.return_value.content = return_value - request = analytics_admin.ListSKAdNetworkConversionValueSchemasRequest() + request = analytics_admin.DeleteKeyEventRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = ( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse() - ) - post_with_metadata.return_value = ( - analytics_admin.ListSKAdNetworkConversionValueSchemasResponse(), - metadata, - ) - client.list_sk_ad_network_conversion_value_schemas( + client.delete_key_event( request, metadata=[ ("key", "val"), @@ -97910,18 +103784,16 @@ def test_list_sk_ad_network_conversion_value_schemas_rest_interceptors( ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_search_change_history_events_rest_bad_request( - request_type=analytics_admin.SearchChangeHistoryEventsRequest, +def test_list_key_events_rest_bad_request( + request_type=analytics_admin.ListKeyEventsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"account": "accounts/sample1"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -97936,29 +103808,29 @@ def test_search_change_history_events_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.search_change_history_events(request) + client.list_key_events(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.SearchChangeHistoryEventsRequest, + analytics_admin.ListKeyEventsRequest, dict, ], ) -def test_search_change_history_events_rest_call_success(request_type): +def test_list_key_events_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"account": "accounts/sample1"} + request_init = {"parent": "properties/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 = analytics_admin.SearchChangeHistoryEventsResponse( + return_value = analytics_admin.ListKeyEventsResponse( next_page_token="next_page_token_value", ) @@ -97967,22 +103839,20 @@ def test_search_change_history_events_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.SearchChangeHistoryEventsResponse.pb( - return_value - ) + return_value = analytics_admin.ListKeyEventsResponse.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.search_change_history_events(request) + response = client.list_key_events(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.SearchChangeHistoryEventsPager) + assert isinstance(response, pagers.ListKeyEventsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_search_change_history_events_rest_interceptors(null_interceptor): +def test_list_key_events_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -97996,20 +103866,18 @@ def test_search_change_history_events_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_search_change_history_events", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_key_events" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_search_change_history_events_with_metadata", + "post_list_key_events_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_search_change_history_events", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_key_events" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.SearchChangeHistoryEventsRequest.pb( - analytics_admin.SearchChangeHistoryEventsRequest() + pb_message = analytics_admin.ListKeyEventsRequest.pb( + analytics_admin.ListKeyEventsRequest() ) transcode.return_value = { "method": "post", @@ -98021,24 +103889,24 @@ def test_search_change_history_events_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 = analytics_admin.SearchChangeHistoryEventsResponse.to_json( - analytics_admin.SearchChangeHistoryEventsResponse() + return_value = analytics_admin.ListKeyEventsResponse.to_json( + analytics_admin.ListKeyEventsResponse() ) req.return_value.content = return_value - request = analytics_admin.SearchChangeHistoryEventsRequest() + request = analytics_admin.ListKeyEventsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.SearchChangeHistoryEventsResponse() + post.return_value = analytics_admin.ListKeyEventsResponse() post_with_metadata.return_value = ( - analytics_admin.SearchChangeHistoryEventsResponse(), + analytics_admin.ListKeyEventsResponse(), metadata, ) - client.search_change_history_events( + client.list_key_events( request, metadata=[ ("key", "val"), @@ -98051,14 +103919,14 @@ def test_search_change_history_events_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_google_signals_settings_rest_bad_request( - request_type=analytics_admin.GetGoogleSignalsSettingsRequest, +def test_get_display_video360_advertiser_link_rest_bad_request( + request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/googleSignalsSettings"} + request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -98073,32 +103941,32 @@ def test_get_google_signals_settings_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_google_signals_settings(request) + client.get_display_video360_advertiser_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetGoogleSignalsSettingsRequest, + analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, dict, ], ) -def test_get_google_signals_settings_rest_call_success(request_type): +def test_get_display_video360_advertiser_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/googleSignalsSettings"} + request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/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 = resources.GoogleSignalsSettings( + return_value = resources.DisplayVideo360AdvertiserLink( name="name_value", - state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, - consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", ) # Wrap the value into a proper Response obj @@ -98106,25 +103974,22 @@ def test_get_google_signals_settings_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleSignalsSettings.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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_google_signals_settings(request) + response = client.get_display_video360_advertiser_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.GoogleSignalsSettings) + assert isinstance(response, resources.DisplayVideo360AdvertiserLink) assert response.name == "name_value" - assert response.state == resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED - assert ( - response.consent - == resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED - ) + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_google_signals_settings_rest_interceptors(null_interceptor): +def test_get_display_video360_advertiser_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -98139,19 +104004,19 @@ def test_get_google_signals_settings_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_google_signals_settings", + "post_get_display_video360_advertiser_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_google_signals_settings_with_metadata", + "post_get_display_video360_advertiser_link_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_google_signals_settings", + "pre_get_display_video360_advertiser_link", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetGoogleSignalsSettingsRequest.pb( - analytics_admin.GetGoogleSignalsSettingsRequest() + pb_message = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest.pb( + analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() ) transcode.return_value = { "method": "post", @@ -98163,21 +104028,24 @@ def test_get_google_signals_settings_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.GoogleSignalsSettings.to_json( - resources.GoogleSignalsSettings() + return_value = resources.DisplayVideo360AdvertiserLink.to_json( + resources.DisplayVideo360AdvertiserLink() ) req.return_value.content = return_value - request = analytics_admin.GetGoogleSignalsSettingsRequest() + request = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.GoogleSignalsSettings() - post_with_metadata.return_value = resources.GoogleSignalsSettings(), metadata + post.return_value = resources.DisplayVideo360AdvertiserLink() + post_with_metadata.return_value = ( + resources.DisplayVideo360AdvertiserLink(), + metadata, + ) - client.get_google_signals_settings( + client.get_display_video360_advertiser_link( request, metadata=[ ("key", "val"), @@ -98190,16 +104058,14 @@ def test_get_google_signals_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_google_signals_settings_rest_bad_request( - request_type=analytics_admin.UpdateGoogleSignalsSettingsRequest, +def test_list_display_video360_advertiser_links_rest_bad_request( + request_type=analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "google_signals_settings": {"name": "properties/sample1/googleSignalsSettings"} - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -98214,110 +104080,30 @@ def test_update_google_signals_settings_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_google_signals_settings(request) + client.list_display_video360_advertiser_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateGoogleSignalsSettingsRequest, + analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, dict, ], ) -def test_update_google_signals_settings_rest_call_success(request_type): +def test_list_display_video360_advertiser_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "google_signals_settings": {"name": "properties/sample1/googleSignalsSettings"} - } - request_init["google_signals_settings"] = { - "name": "properties/sample1/googleSignalsSettings", - "state": 1, - "consent": 2, - } - # 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 = analytics_admin.UpdateGoogleSignalsSettingsRequest.meta.fields[ - "google_signals_settings" - ] - - 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[ - "google_signals_settings" - ].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["google_signals_settings"][field])): - del request_init["google_signals_settings"][field][i][subfield] - else: - del request_init["google_signals_settings"][field][subfield] + request_init = {"parent": "properties/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.GoogleSignalsSettings( - name="name_value", - state=resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED, - consent=resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED, + return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -98325,25 +104111,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.GoogleSignalsSettings.pb(return_value) + return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.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_google_signals_settings(request) + response = client.list_display_video360_advertiser_links(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.GoogleSignalsSettings) - assert response.name == "name_value" - assert response.state == resources.GoogleSignalsState.GOOGLE_SIGNALS_ENABLED - assert ( - response.consent - == resources.GoogleSignalsConsent.GOOGLE_SIGNALS_CONSENT_CONSENTED - ) + assert isinstance(response, pagers.ListDisplayVideo360AdvertiserLinksPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_google_signals_settings_rest_interceptors(null_interceptor): +def test_list_display_video360_advertiser_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -98358,19 +104141,19 @@ def test_update_google_signals_settings_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_google_signals_settings", + "post_list_display_video360_advertiser_links", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_google_signals_settings_with_metadata", + "post_list_display_video360_advertiser_links_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_google_signals_settings", + "pre_list_display_video360_advertiser_links", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateGoogleSignalsSettingsRequest.pb( - analytics_admin.UpdateGoogleSignalsSettingsRequest() + pb_message = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest.pb( + analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() ) transcode.return_value = { "method": "post", @@ -98382,21 +104165,26 @@ def test_update_google_signals_settings_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.GoogleSignalsSettings.to_json( - resources.GoogleSignalsSettings() + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.to_json( + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() + ) ) req.return_value.content = return_value - request = analytics_admin.UpdateGoogleSignalsSettingsRequest() + request = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.GoogleSignalsSettings() - post_with_metadata.return_value = resources.GoogleSignalsSettings(), metadata + post.return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() + post_with_metadata.return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinksResponse(), + metadata, + ) - client.update_google_signals_settings( + client.list_display_video360_advertiser_links( request, metadata=[ ("key", "val"), @@ -98409,8 +104197,8 @@ def test_update_google_signals_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_conversion_event_rest_bad_request( - request_type=analytics_admin.CreateConversionEventRequest, +def test_create_display_video360_advertiser_link_rest_bad_request( + request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -98431,42 +104219,38 @@ def test_create_conversion_event_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_conversion_event(request) + client.create_display_video360_advertiser_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateConversionEventRequest, + analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, dict, ], ) -def test_create_conversion_event_rest_call_success(request_type): +def test_create_display_video360_advertiser_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["conversion_event"] = { + request_init["display_video_360_advertiser_link"] = { "name": "name_value", - "event_name": "event_name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "deletable": True, - "custom": True, - "counting_method": 1, - "default_conversion_value": { - "value": 0.541, - "currency_code": "currency_code_value", - }, + "advertiser_id": "advertiser_id_value", + "advertiser_display_name": "advertiser_display_name_value", + "ads_personalization_enabled": {"value": True}, + "campaign_data_sharing_enabled": {}, + "cost_data_sharing_enabled": {}, } # 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 = analytics_admin.CreateConversionEventRequest.meta.fields[ - "conversion_event" + test_field = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest.meta.fields[ + "display_video_360_advertiser_link" ] def get_message_fields(field): @@ -98495,7 +104279,9 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["conversion_event"].items(): # pragma: NO COVER + for field, value in request_init[ + "display_video_360_advertiser_link" + ].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -98525,21 +104311,23 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["conversion_event"][field])): - del request_init["conversion_event"][field][i][subfield] + for i in range( + 0, len(request_init["display_video_360_advertiser_link"][field]) + ): + del request_init["display_video_360_advertiser_link"][field][i][ + subfield + ] else: - del request_init["conversion_event"][field][subfield] + del request_init["display_video_360_advertiser_link"][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 = resources.ConversionEvent( + return_value = resources.DisplayVideo360AdvertiserLink( name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", ) # Wrap the value into a proper Response obj @@ -98547,27 +104335,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.ConversionEvent.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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.create_conversion_event(request) + response = client.create_display_video360_advertiser_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.ConversionEvent) + assert isinstance(response, resources.DisplayVideo360AdvertiserLink) assert response.name == "name_value" - assert response.event_name == "event_name_value" - assert response.deletable is True - assert response.custom is True - assert ( - response.counting_method - == resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT - ) + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_conversion_event_rest_interceptors(null_interceptor): +def test_create_display_video360_advertiser_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -98581,18 +104364,20 @@ def test_create_conversion_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_conversion_event" + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_display_video360_advertiser_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_conversion_event_with_metadata", + "post_create_display_video360_advertiser_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_conversion_event" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_create_display_video360_advertiser_link", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateConversionEventRequest.pb( - analytics_admin.CreateConversionEventRequest() + pb_message = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest.pb( + analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() ) transcode.return_value = { "method": "post", @@ -98604,19 +104389,24 @@ def test_create_conversion_event_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.ConversionEvent.to_json(resources.ConversionEvent()) + return_value = resources.DisplayVideo360AdvertiserLink.to_json( + resources.DisplayVideo360AdvertiserLink() + ) req.return_value.content = return_value - request = analytics_admin.CreateConversionEventRequest() + request = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.ConversionEvent() - post_with_metadata.return_value = resources.ConversionEvent(), metadata + post.return_value = resources.DisplayVideo360AdvertiserLink() + post_with_metadata.return_value = ( + resources.DisplayVideo360AdvertiserLink(), + metadata, + ) - client.create_conversion_event( + client.create_display_video360_advertiser_link( request, metadata=[ ("key", "val"), @@ -98629,16 +104419,14 @@ def test_create_conversion_event_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_conversion_event_rest_bad_request( - request_type=analytics_admin.UpdateConversionEventRequest, +def test_delete_display_video360_advertiser_link_rest_bad_request( + request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "conversion_event": {"name": "properties/sample1/conversionEvents/sample2"} - } + request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -98653,145 +104441,45 @@ def test_update_conversion_event_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_conversion_event(request) + client.delete_display_video360_advertiser_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateConversionEventRequest, + analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, dict, ], ) -def test_update_conversion_event_rest_call_success(request_type): +def test_delete_display_video360_advertiser_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "conversion_event": {"name": "properties/sample1/conversionEvents/sample2"} - } - request_init["conversion_event"] = { - "name": "properties/sample1/conversionEvents/sample2", - "event_name": "event_name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "deletable": True, - "custom": True, - "counting_method": 1, - "default_conversion_value": { - "value": 0.541, - "currency_code": "currency_code_value", - }, - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateConversionEventRequest.meta.fields[ - "conversion_event" - ] - - 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["conversion_event"].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["conversion_event"][field])): - del request_init["conversion_event"][field][i][subfield] - else: - del request_init["conversion_event"][field][subfield] + request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/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 = resources.ConversionEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, - ) + return_value = None # 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.ConversionEvent.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"} - response = client.update_conversion_event(request) + response = client.delete_display_video360_advertiser_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.ConversionEvent) - assert response.name == "name_value" - assert response.event_name == "event_name_value" - assert response.deletable is True - assert response.custom is True - assert ( - response.counting_method - == resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT - ) + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_conversion_event_rest_interceptors(null_interceptor): +def test_delete_display_video360_advertiser_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -98805,18 +104493,12 @@ def test_update_conversion_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_conversion_event" - ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_conversion_event_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_conversion_event" + "pre_delete_display_video360_advertiser_link", ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateConversionEventRequest.pb( - analytics_admin.UpdateConversionEventRequest() + pb_message = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest.pb( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() ) transcode.return_value = { "method": "post", @@ -98828,19 +104510,15 @@ def test_update_conversion_event_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.ConversionEvent.to_json(resources.ConversionEvent()) - req.return_value.content = return_value - request = analytics_admin.UpdateConversionEventRequest() + request = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.ConversionEvent() - post_with_metadata.return_value = resources.ConversionEvent(), metadata - client.update_conversion_event( + client.delete_display_video360_advertiser_link( request, metadata=[ ("key", "val"), @@ -98849,18 +104527,20 @@ def test_update_conversion_event_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_get_conversion_event_rest_bad_request( - request_type=analytics_admin.GetConversionEventRequest, +def test_update_display_video360_advertiser_link_rest_bad_request( + request_type=analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/conversionEvents/sample2"} + request_init = { + "display_video_360_advertiser_link": { + "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -98875,34 +104555,119 @@ def test_get_conversion_event_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_conversion_event(request) + client.update_display_video360_advertiser_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetConversionEventRequest, + analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, dict, ], ) -def test_get_conversion_event_rest_call_success(request_type): +def test_update_display_video360_advertiser_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/conversionEvents/sample2"} + request_init = { + "display_video_360_advertiser_link": { + "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" + } + } + request_init["display_video_360_advertiser_link"] = { + "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2", + "advertiser_id": "advertiser_id_value", + "advertiser_display_name": "advertiser_display_name_value", + "ads_personalization_enabled": {"value": True}, + "campaign_data_sharing_enabled": {}, + "cost_data_sharing_enabled": {}, + } + # 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 = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest.meta.fields[ + "display_video_360_advertiser_link" + ] + + 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[ + "display_video_360_advertiser_link" + ].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["display_video_360_advertiser_link"][field]) + ): + del request_init["display_video_360_advertiser_link"][field][i][ + subfield + ] + else: + del request_init["display_video_360_advertiser_link"][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 = resources.ConversionEvent( + return_value = resources.DisplayVideo360AdvertiserLink( name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT, + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", ) # Wrap the value into a proper Response obj @@ -98910,27 +104675,22 @@ def test_get_conversion_event_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.ConversionEvent.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLink.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_conversion_event(request) + response = client.update_display_video360_advertiser_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.ConversionEvent) + assert isinstance(response, resources.DisplayVideo360AdvertiserLink) assert response.name == "name_value" - assert response.event_name == "event_name_value" - assert response.deletable is True - assert response.custom is True - assert ( - response.counting_method - == resources.ConversionEvent.ConversionCountingMethod.ONCE_PER_EVENT - ) + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_conversion_event_rest_interceptors(null_interceptor): +def test_update_display_video360_advertiser_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -98944,18 +104704,20 @@ def test_get_conversion_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_conversion_event" + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_display_video360_advertiser_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_conversion_event_with_metadata", + "post_update_display_video360_advertiser_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_conversion_event" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_update_display_video360_advertiser_link", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetConversionEventRequest.pb( - analytics_admin.GetConversionEventRequest() + pb_message = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest.pb( + analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() ) transcode.return_value = { "method": "post", @@ -98967,19 +104729,24 @@ def test_get_conversion_event_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.ConversionEvent.to_json(resources.ConversionEvent()) + return_value = resources.DisplayVideo360AdvertiserLink.to_json( + resources.DisplayVideo360AdvertiserLink() + ) req.return_value.content = return_value - request = analytics_admin.GetConversionEventRequest() + request = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.ConversionEvent() - post_with_metadata.return_value = resources.ConversionEvent(), metadata + post.return_value = resources.DisplayVideo360AdvertiserLink() + post_with_metadata.return_value = ( + resources.DisplayVideo360AdvertiserLink(), + metadata, + ) - client.get_conversion_event( + client.update_display_video360_advertiser_link( request, metadata=[ ("key", "val"), @@ -98992,14 +104759,16 @@ def test_get_conversion_event_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_conversion_event_rest_bad_request( - request_type=analytics_admin.DeleteConversionEventRequest, +def test_get_display_video360_advertiser_link_proposal_rest_bad_request( + request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/conversionEvents/sample2"} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -99014,45 +104783,61 @@ def test_delete_conversion_event_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_conversion_event(request) + client.get_display_video360_advertiser_link_proposal(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteConversionEventRequest, + analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, dict, ], ) -def test_delete_conversion_event_rest_call_success(request_type): +def test_get_display_video360_advertiser_link_proposal_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/conversionEvents/sample2"} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.DisplayVideo360AdvertiserLinkProposal( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + validation_email="validation_email_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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_conversion_event(request) + response = client.get_display_video360_advertiser_link_proposal(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.DisplayVideo360AdvertiserLinkProposal) + assert response.name == "name_value" + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" + assert response.validation_email == "validation_email_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_conversion_event_rest_interceptors(null_interceptor): +def test_get_display_video360_advertiser_link_proposal_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99066,11 +104851,20 @@ def test_delete_conversion_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_conversion_event" + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_display_video360_advertiser_link_proposal", + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_display_video360_advertiser_link_proposal_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "pre_get_display_video360_advertiser_link_proposal", ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteConversionEventRequest.pb( - analytics_admin.DeleteConversionEventRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest.pb( + analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() ) transcode.return_value = { "method": "post", @@ -99082,15 +104876,24 @@ def test_delete_conversion_event_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.DisplayVideo360AdvertiserLinkProposal.to_json( + resources.DisplayVideo360AdvertiserLinkProposal() + ) + req.return_value.content = return_value - request = analytics_admin.DeleteConversionEventRequest() + request = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.DisplayVideo360AdvertiserLinkProposal() + post_with_metadata.return_value = ( + resources.DisplayVideo360AdvertiserLinkProposal(), + metadata, + ) - client.delete_conversion_event( + client.get_display_video360_advertiser_link_proposal( request, metadata=[ ("key", "val"), @@ -99099,10 +104902,12 @@ def test_delete_conversion_event_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_list_conversion_events_rest_bad_request( - request_type=analytics_admin.ListConversionEventsRequest, +def test_list_display_video360_advertiser_link_proposals_rest_bad_request( + request_type=analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -99123,17 +104928,19 @@ def test_list_conversion_events_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.list_conversion_events(request) + client.list_display_video360_advertiser_link_proposals(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListConversionEventsRequest, + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, dict, ], ) -def test_list_conversion_events_rest_call_success(request_type): +def test_list_display_video360_advertiser_link_proposals_rest_call_success( + request_type, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -99145,8 +104952,10 @@ def test_list_conversion_events_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListConversionEventsResponse( - next_page_token="next_page_token_value", + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( + next_page_token="next_page_token_value", + ) ) # Wrap the value into a proper Response obj @@ -99154,20 +104963,26 @@ def test_list_conversion_events_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListConversionEventsResponse.pb(return_value) + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.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_conversion_events(request) + response = client.list_display_video360_advertiser_link_proposals(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListConversionEventsPager) + assert isinstance(response, pagers.ListDisplayVideo360AdvertiserLinkProposalsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_conversion_events_rest_interceptors(null_interceptor): +def test_list_display_video360_advertiser_link_proposals_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99181,18 +104996,22 @@ def test_list_conversion_events_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_conversion_events" + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_display_video360_advertiser_link_proposals", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_conversion_events_with_metadata", + "post_list_display_video360_advertiser_link_proposals_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_conversion_events" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_list_display_video360_advertiser_link_proposals", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListConversionEventsRequest.pb( - analytics_admin.ListConversionEventsRequest() + pb_message = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest.pb( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() + ) ) transcode.return_value = { "method": "post", @@ -99204,24 +105023,28 @@ def test_list_conversion_events_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 = analytics_admin.ListConversionEventsResponse.to_json( - analytics_admin.ListConversionEventsResponse() + return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.to_json( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() + ) ) req.return_value.content = return_value - request = analytics_admin.ListConversionEventsRequest() + request = analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListConversionEventsResponse() + post.return_value = ( + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() + ) post_with_metadata.return_value = ( - analytics_admin.ListConversionEventsResponse(), + analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse(), metadata, ) - client.list_conversion_events( + client.list_display_video360_advertiser_link_proposals( request, metadata=[ ("key", "val"), @@ -99234,8 +105057,8 @@ def test_list_conversion_events_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_key_event_rest_bad_request( - request_type=analytics_admin.CreateKeyEventRequest, +def test_create_display_video360_advertiser_link_proposal_rest_bad_request( + request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -99256,41 +105079,49 @@ def test_create_key_event_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_key_event(request) + client.create_display_video360_advertiser_link_proposal(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateKeyEventRequest, + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, dict, ], ) -def test_create_key_event_rest_call_success(request_type): +def test_create_display_video360_advertiser_link_proposal_rest_call_success( + request_type, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["key_event"] = { + request_init["display_video_360_advertiser_link_proposal"] = { "name": "name_value", - "event_name": "event_name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "deletable": True, - "custom": True, - "counting_method": 1, - "default_value": { - "numeric_value": 0.1391, - "currency_code": "currency_code_value", + "advertiser_id": "advertiser_id_value", + "link_proposal_status_details": { + "link_proposal_initiating_product": 1, + "requestor_email": "requestor_email_value", + "link_proposal_state": 1, }, + "advertiser_display_name": "advertiser_display_name_value", + "validation_email": "validation_email_value", + "ads_personalization_enabled": {"value": True}, + "campaign_data_sharing_enabled": {}, + "cost_data_sharing_enabled": {}, } # 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 = analytics_admin.CreateKeyEventRequest.meta.fields["key_event"] + test_field = ( + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest.meta.fields[ + "display_video_360_advertiser_link_proposal" + ] + ) def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -99318,7 +105149,9 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["key_event"].items(): # pragma: NO COVER + for field, value in request_init[ + "display_video_360_advertiser_link_proposal" + ].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -99348,21 +105181,31 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["key_event"][field])): - del request_init["key_event"][field][i][subfield] + for i in range( + 0, + len( + request_init["display_video_360_advertiser_link_proposal"][ + field + ] + ), + ): + del request_init["display_video_360_advertiser_link_proposal"][ + field + ][i][subfield] else: - del request_init["key_event"][field][subfield] + del request_init["display_video_360_advertiser_link_proposal"][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 = resources.KeyEvent( + return_value = resources.DisplayVideo360AdvertiserLinkProposal( name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + validation_email="validation_email_value", ) # Wrap the value into a proper Response obj @@ -99370,24 +105213,25 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.KeyEvent.pb(return_value) + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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.create_key_event(request) + response = client.create_display_video360_advertiser_link_proposal(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.KeyEvent) + assert isinstance(response, resources.DisplayVideo360AdvertiserLinkProposal) assert response.name == "name_value" - assert response.event_name == "event_name_value" - assert response.deletable is True - assert response.custom is True - assert response.counting_method == resources.KeyEvent.CountingMethod.ONCE_PER_EVENT + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" + assert response.validation_email == "validation_email_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_key_event_rest_interceptors(null_interceptor): +def test_create_display_video360_advertiser_link_proposal_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99401,18 +105245,22 @@ def test_create_key_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_key_event" + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_display_video360_advertiser_link_proposal", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_key_event_with_metadata", + "post_create_display_video360_advertiser_link_proposal_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_key_event" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_create_display_video360_advertiser_link_proposal", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateKeyEventRequest.pb( - analytics_admin.CreateKeyEventRequest() + pb_message = ( + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest.pb( + analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() + ) ) transcode.return_value = { "method": "post", @@ -99424,19 +105272,24 @@ def test_create_key_event_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.KeyEvent.to_json(resources.KeyEvent()) + return_value = resources.DisplayVideo360AdvertiserLinkProposal.to_json( + resources.DisplayVideo360AdvertiserLinkProposal() + ) req.return_value.content = return_value - request = analytics_admin.CreateKeyEventRequest() + request = analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.KeyEvent() - post_with_metadata.return_value = resources.KeyEvent(), metadata + post.return_value = resources.DisplayVideo360AdvertiserLinkProposal() + post_with_metadata.return_value = ( + resources.DisplayVideo360AdvertiserLinkProposal(), + metadata, + ) - client.create_key_event( + client.create_display_video360_advertiser_link_proposal( request, metadata=[ ("key", "val"), @@ -99449,14 +105302,16 @@ def test_create_key_event_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_key_event_rest_bad_request( - request_type=analytics_admin.UpdateKeyEventRequest, +def test_delete_display_video360_advertiser_link_proposal_rest_bad_request( + request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"key_event": {"name": "properties/sample1/keyEvents/sample2"}} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -99471,138 +105326,51 @@ def test_update_key_event_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_key_event(request) + client.delete_display_video360_advertiser_link_proposal(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateKeyEventRequest, + analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, dict, ], ) -def test_update_key_event_rest_call_success(request_type): +def test_delete_display_video360_advertiser_link_proposal_rest_call_success( + request_type, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"key_event": {"name": "properties/sample1/keyEvents/sample2"}} - request_init["key_event"] = { - "name": "properties/sample1/keyEvents/sample2", - "event_name": "event_name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "deletable": True, - "custom": True, - "counting_method": 1, - "default_value": { - "numeric_value": 0.1391, - "currency_code": "currency_code_value", - }, + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" } - # 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 = analytics_admin.UpdateKeyEventRequest.meta.fields["key_event"] - - 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["key_event"].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["key_event"][field])): - del request_init["key_event"][field][i][subfield] - else: - del request_init["key_event"][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 = resources.KeyEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, - ) + return_value = None # 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.KeyEvent.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"} - response = client.update_key_event(request) + response = client.delete_display_video360_advertiser_link_proposal(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.KeyEvent) - assert response.name == "name_value" - assert response.event_name == "event_name_value" - assert response.deletable is True - assert response.custom is True - assert response.counting_method == resources.KeyEvent.CountingMethod.ONCE_PER_EVENT + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_key_event_rest_interceptors(null_interceptor): +def test_delete_display_video360_advertiser_link_proposal_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99616,18 +105384,14 @@ def test_update_key_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_key_event" - ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_key_event_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_key_event" + "pre_delete_display_video360_advertiser_link_proposal", ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateKeyEventRequest.pb( - analytics_admin.UpdateKeyEventRequest() + pb_message = ( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest.pb( + analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() + ) ) transcode.return_value = { "method": "post", @@ -99639,19 +105403,15 @@ def test_update_key_event_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.KeyEvent.to_json(resources.KeyEvent()) - req.return_value.content = return_value - request = analytics_admin.UpdateKeyEventRequest() + request = analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.KeyEvent() - post_with_metadata.return_value = resources.KeyEvent(), metadata - client.update_key_event( + client.delete_display_video360_advertiser_link_proposal( request, metadata=[ ("key", "val"), @@ -99660,18 +105420,18 @@ def test_update_key_event_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_get_key_event_rest_bad_request( - request_type=analytics_admin.GetKeyEventRequest, +def test_approve_display_video360_advertiser_link_proposal_rest_bad_request( + request_type=analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/keyEvents/sample2"} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -99686,34 +105446,34 @@ def test_get_key_event_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_key_event(request) + client.approve_display_video360_advertiser_link_proposal(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetKeyEventRequest, + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, dict, ], ) -def test_get_key_event_rest_call_success(request_type): +def test_approve_display_video360_advertiser_link_proposal_rest_call_success( + request_type, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/keyEvents/sample2"} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/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 = resources.KeyEvent( - name="name_value", - event_name="event_name_value", - deletable=True, - custom=True, - counting_method=resources.KeyEvent.CountingMethod.ONCE_PER_EVENT, + return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() ) # Wrap the value into a proper Response obj @@ -99721,24 +105481,27 @@ def test_get_key_event_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.KeyEvent.pb(return_value) + return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse.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_key_event(request) + response = client.approve_display_video360_advertiser_link_proposal(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.KeyEvent) - assert response.name == "name_value" - assert response.event_name == "event_name_value" - assert response.deletable is True - assert response.custom is True - assert response.counting_method == resources.KeyEvent.CountingMethod.ONCE_PER_EVENT + assert isinstance( + response, analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_key_event_rest_interceptors(null_interceptor): +def test_approve_display_video360_advertiser_link_proposal_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99752,18 +105515,22 @@ def test_get_key_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_key_event" + transports.AnalyticsAdminServiceRestInterceptor, + "post_approve_display_video360_advertiser_link_proposal", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_key_event_with_metadata", + "post_approve_display_video360_advertiser_link_proposal_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_key_event" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_approve_display_video360_advertiser_link_proposal", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetKeyEventRequest.pb( - analytics_admin.GetKeyEventRequest() + pb_message = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest.pb( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() + ) ) transcode.return_value = { "method": "post", @@ -99775,19 +105542,26 @@ def test_get_key_event_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.KeyEvent.to_json(resources.KeyEvent()) + return_value = analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse.to_json( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + ) req.return_value.content = return_value - request = analytics_admin.GetKeyEventRequest() + request = analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.KeyEvent() - post_with_metadata.return_value = resources.KeyEvent(), metadata + post.return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + ) + post_with_metadata.return_value = ( + analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse(), + metadata, + ) - client.get_key_event( + client.approve_display_video360_advertiser_link_proposal( request, metadata=[ ("key", "val"), @@ -99800,14 +105574,16 @@ def test_get_key_event_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_key_event_rest_bad_request( - request_type=analytics_admin.DeleteKeyEventRequest, +def test_cancel_display_video360_advertiser_link_proposal_rest_bad_request( + request_type=analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/keyEvents/sample2"} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -99822,45 +105598,63 @@ def test_delete_key_event_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_key_event(request) + client.cancel_display_video360_advertiser_link_proposal(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteKeyEventRequest, + analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, dict, ], ) -def test_delete_key_event_rest_call_success(request_type): +def test_cancel_display_video360_advertiser_link_proposal_rest_call_success( + request_type, +): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/keyEvents/sample2"} + request_init = { + "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.DisplayVideo360AdvertiserLinkProposal( + name="name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", + validation_email="validation_email_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.DisplayVideo360AdvertiserLinkProposal.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_key_event(request) + response = client.cancel_display_video360_advertiser_link_proposal(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.DisplayVideo360AdvertiserLinkProposal) + assert response.name == "name_value" + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" + assert response.validation_email == "validation_email_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_key_event_rest_interceptors(null_interceptor): +def test_cancel_display_video360_advertiser_link_proposal_rest_interceptors( + null_interceptor, +): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99874,11 +105668,22 @@ def test_delete_key_event_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_key_event" + transports.AnalyticsAdminServiceRestInterceptor, + "post_cancel_display_video360_advertiser_link_proposal", + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_cancel_display_video360_advertiser_link_proposal_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "pre_cancel_display_video360_advertiser_link_proposal", ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteKeyEventRequest.pb( - analytics_admin.DeleteKeyEventRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = ( + analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest.pb( + analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() + ) ) transcode.return_value = { "method": "post", @@ -99890,15 +105695,24 @@ def test_delete_key_event_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.DisplayVideo360AdvertiserLinkProposal.to_json( + resources.DisplayVideo360AdvertiserLinkProposal() + ) + req.return_value.content = return_value - request = analytics_admin.DeleteKeyEventRequest() + request = analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.DisplayVideo360AdvertiserLinkProposal() + post_with_metadata.return_value = ( + resources.DisplayVideo360AdvertiserLinkProposal(), + metadata, + ) - client.delete_key_event( + client.cancel_display_video360_advertiser_link_proposal( request, metadata=[ ("key", "val"), @@ -99907,10 +105721,12 @@ def test_delete_key_event_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_list_key_events_rest_bad_request( - request_type=analytics_admin.ListKeyEventsRequest, +def test_create_custom_dimension_rest_bad_request( + request_type=analytics_admin.CreateCustomDimensionRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -99931,30 +105747,112 @@ def test_list_key_events_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.list_key_events(request) + client.create_custom_dimension(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListKeyEventsRequest, + analytics_admin.CreateCustomDimensionRequest, dict, ], ) -def test_list_key_events_rest_call_success(request_type): +def test_create_custom_dimension_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} + request_init["custom_dimension"] = { + "name": "name_value", + "parameter_name": "parameter_name_value", + "display_name": "display_name_value", + "description": "description_value", + "scope": 1, + "disallow_ads_personalization": True, + } + # 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 = analytics_admin.CreateCustomDimensionRequest.meta.fields[ + "custom_dimension" + ] + + 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["custom_dimension"].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["custom_dimension"][field])): + del request_init["custom_dimension"][field][i][subfield] + else: + del request_init["custom_dimension"][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 = analytics_admin.ListKeyEventsResponse( - next_page_token="next_page_token_value", + return_value = resources.CustomDimension( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + scope=resources.CustomDimension.DimensionScope.EVENT, + disallow_ads_personalization=True, ) # Wrap the value into a proper Response obj @@ -99962,20 +105860,25 @@ def test_list_key_events_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListKeyEventsResponse.pb(return_value) + return_value = resources.CustomDimension.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_key_events(request) + response = client.create_custom_dimension(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListKeyEventsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.CustomDimension) + assert response.name == "name_value" + assert response.parameter_name == "parameter_name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.scope == resources.CustomDimension.DimensionScope.EVENT + assert response.disallow_ads_personalization is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_key_events_rest_interceptors(null_interceptor): +def test_create_custom_dimension_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -99989,18 +105892,18 @@ def test_list_key_events_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_key_events" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_custom_dimension" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_key_events_with_metadata", + "post_create_custom_dimension_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_key_events" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_custom_dimension" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListKeyEventsRequest.pb( - analytics_admin.ListKeyEventsRequest() + pb_message = analytics_admin.CreateCustomDimensionRequest.pb( + analytics_admin.CreateCustomDimensionRequest() ) transcode.return_value = { "method": "post", @@ -100010,26 +105913,21 @@ def test_list_key_events_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 = analytics_admin.ListKeyEventsResponse.to_json( - analytics_admin.ListKeyEventsResponse() - ) + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = resources.CustomDimension.to_json(resources.CustomDimension()) req.return_value.content = return_value - request = analytics_admin.ListKeyEventsRequest() + request = analytics_admin.CreateCustomDimensionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListKeyEventsResponse() - post_with_metadata.return_value = ( - analytics_admin.ListKeyEventsResponse(), - metadata, - ) + post.return_value = resources.CustomDimension() + post_with_metadata.return_value = resources.CustomDimension(), metadata - client.list_key_events( + client.create_custom_dimension( request, metadata=[ ("key", "val"), @@ -100042,14 +105940,16 @@ def test_list_key_events_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_display_video360_advertiser_link_rest_bad_request( - request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, +def test_update_custom_dimension_rest_bad_request( + request_type=analytics_admin.UpdateCustomDimensionRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/sample2"} + request_init = { + "custom_dimension": {"name": "properties/sample1/customDimensions/sample2"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -100064,32 +105964,114 @@ def test_get_display_video360_advertiser_link_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_display_video360_advertiser_link(request) + client.update_custom_dimension(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetDisplayVideo360AdvertiserLinkRequest, + analytics_admin.UpdateCustomDimensionRequest, dict, ], ) -def test_get_display_video360_advertiser_link_rest_call_success(request_type): +def test_update_custom_dimension_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/sample2"} + request_init = { + "custom_dimension": {"name": "properties/sample1/customDimensions/sample2"} + } + request_init["custom_dimension"] = { + "name": "properties/sample1/customDimensions/sample2", + "parameter_name": "parameter_name_value", + "display_name": "display_name_value", + "description": "description_value", + "scope": 1, + "disallow_ads_personalization": True, + } + # 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 = analytics_admin.UpdateCustomDimensionRequest.meta.fields[ + "custom_dimension" + ] + + 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["custom_dimension"].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["custom_dimension"][field])): + del request_init["custom_dimension"][field][i][subfield] + else: + del request_init["custom_dimension"][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 = resources.DisplayVideo360AdvertiserLink( + return_value = resources.CustomDimension( name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + scope=resources.CustomDimension.DimensionScope.EVENT, + disallow_ads_personalization=True, ) # Wrap the value into a proper Response obj @@ -100097,22 +106079,25 @@ def test_get_display_video360_advertiser_link_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLink.pb(return_value) + return_value = resources.CustomDimension.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_display_video360_advertiser_link(request) + response = client.update_custom_dimension(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DisplayVideo360AdvertiserLink) + assert isinstance(response, resources.CustomDimension) assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" + assert response.parameter_name == "parameter_name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.scope == resources.CustomDimension.DimensionScope.EVENT + assert response.disallow_ads_personalization is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_display_video360_advertiser_link_rest_interceptors(null_interceptor): +def test_update_custom_dimension_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -100126,20 +106111,18 @@ def test_get_display_video360_advertiser_link_rest_interceptors(null_interceptor ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_display_video360_advertiser_link", + transports.AnalyticsAdminServiceRestInterceptor, "post_update_custom_dimension" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_display_video360_advertiser_link_with_metadata", + "post_update_custom_dimension_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_display_video360_advertiser_link", + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_custom_dimension" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest.pb( - analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() + pb_message = analytics_admin.UpdateCustomDimensionRequest.pb( + analytics_admin.UpdateCustomDimensionRequest() ) transcode.return_value = { "method": "post", @@ -100151,24 +106134,19 @@ def test_get_display_video360_advertiser_link_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.DisplayVideo360AdvertiserLink.to_json( - resources.DisplayVideo360AdvertiserLink() - ) + return_value = resources.CustomDimension.to_json(resources.CustomDimension()) req.return_value.content = return_value - request = analytics_admin.GetDisplayVideo360AdvertiserLinkRequest() + request = analytics_admin.UpdateCustomDimensionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DisplayVideo360AdvertiserLink() - post_with_metadata.return_value = ( - resources.DisplayVideo360AdvertiserLink(), - metadata, - ) + post.return_value = resources.CustomDimension() + post_with_metadata.return_value = resources.CustomDimension(), metadata - client.get_display_video360_advertiser_link( + client.update_custom_dimension( request, metadata=[ ("key", "val"), @@ -100181,8 +106159,8 @@ def test_get_display_video360_advertiser_link_rest_interceptors(null_interceptor post_with_metadata.assert_called_once() -def test_list_display_video360_advertiser_links_rest_bad_request( - request_type=analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, +def test_list_custom_dimensions_rest_bad_request( + request_type=analytics_admin.ListCustomDimensionsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -100203,17 +106181,17 @@ def test_list_display_video360_advertiser_links_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.list_display_video360_advertiser_links(request) + client.list_custom_dimensions(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListDisplayVideo360AdvertiserLinksRequest, + analytics_admin.ListCustomDimensionsRequest, dict, ], ) -def test_list_display_video360_advertiser_links_rest_call_success(request_type): +def test_list_custom_dimensions_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -100225,7 +106203,7 @@ def test_list_display_video360_advertiser_links_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse( + return_value = analytics_admin.ListCustomDimensionsResponse( next_page_token="next_page_token_value", ) @@ -100234,22 +106212,20 @@ def test_list_display_video360_advertiser_links_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.pb( - return_value - ) + return_value = analytics_admin.ListCustomDimensionsResponse.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_display_video360_advertiser_links(request) + response = client.list_custom_dimensions(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListDisplayVideo360AdvertiserLinksPager) + assert isinstance(response, pagers.ListCustomDimensionsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_display_video360_advertiser_links_rest_interceptors(null_interceptor): +def test_list_custom_dimensions_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -100263,20 +106239,18 @@ def test_list_display_video360_advertiser_links_rest_interceptors(null_intercept ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_list_display_video360_advertiser_links", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_custom_dimensions" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_display_video360_advertiser_links_with_metadata", + "post_list_custom_dimensions_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_list_display_video360_advertiser_links", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_custom_dimensions" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest.pb( - analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() + pb_message = analytics_admin.ListCustomDimensionsRequest.pb( + analytics_admin.ListCustomDimensionsRequest() ) transcode.return_value = { "method": "post", @@ -100288,26 +106262,24 @@ def test_list_display_video360_advertiser_links_rest_interceptors(null_intercept 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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse.to_json( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() - ) + return_value = analytics_admin.ListCustomDimensionsResponse.to_json( + analytics_admin.ListCustomDimensionsResponse() ) req.return_value.content = return_value - request = analytics_admin.ListDisplayVideo360AdvertiserLinksRequest() + request = analytics_admin.ListCustomDimensionsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListDisplayVideo360AdvertiserLinksResponse() + post.return_value = analytics_admin.ListCustomDimensionsResponse() post_with_metadata.return_value = ( - analytics_admin.ListDisplayVideo360AdvertiserLinksResponse(), + analytics_admin.ListCustomDimensionsResponse(), metadata, ) - client.list_display_video360_advertiser_links( + client.list_custom_dimensions( request, metadata=[ ("key", "val"), @@ -100320,14 +106292,14 @@ def test_list_display_video360_advertiser_links_rest_interceptors(null_intercept post_with_metadata.assert_called_once() -def test_create_display_video360_advertiser_link_rest_bad_request( - request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, +def test_archive_custom_dimension_rest_bad_request( + request_type=analytics_admin.ArchiveCustomDimensionRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"name": "properties/sample1/customDimensions/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -100342,138 +106314,45 @@ def test_create_display_video360_advertiser_link_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_display_video360_advertiser_link(request) + client.archive_custom_dimension(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest, + analytics_admin.ArchiveCustomDimensionRequest, dict, ], ) -def test_create_display_video360_advertiser_link_rest_call_success(request_type): +def test_archive_custom_dimension_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["display_video_360_advertiser_link"] = { - "name": "name_value", - "advertiser_id": "advertiser_id_value", - "advertiser_display_name": "advertiser_display_name_value", - "ads_personalization_enabled": {"value": True}, - "campaign_data_sharing_enabled": {}, - "cost_data_sharing_enabled": {}, - } - # 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 = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest.meta.fields[ - "display_video_360_advertiser_link" - ] - - 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[ - "display_video_360_advertiser_link" - ].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["display_video_360_advertiser_link"][field]) - ): - del request_init["display_video_360_advertiser_link"][field][i][ - subfield - ] - else: - del request_init["display_video_360_advertiser_link"][field][subfield] + request_init = {"name": "properties/sample1/customDimensions/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 = resources.DisplayVideo360AdvertiserLink( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) + return_value = None # 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.DisplayVideo360AdvertiserLink.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"} - response = client.create_display_video360_advertiser_link(request) + response = client.archive_custom_dimension(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DisplayVideo360AdvertiserLink) - assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_display_video360_advertiser_link_rest_interceptors(null_interceptor): +def test_archive_custom_dimension_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -100487,20 +106366,11 @@ def test_create_display_video360_advertiser_link_rest_interceptors(null_intercep ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_display_video360_advertiser_link", - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_display_video360_advertiser_link_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_create_display_video360_advertiser_link", + transports.AnalyticsAdminServiceRestInterceptor, "pre_archive_custom_dimension" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest.pb( - analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() + pb_message = analytics_admin.ArchiveCustomDimensionRequest.pb( + analytics_admin.ArchiveCustomDimensionRequest() ) transcode.return_value = { "method": "post", @@ -100512,24 +106382,15 @@ def test_create_display_video360_advertiser_link_rest_interceptors(null_intercep 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.DisplayVideo360AdvertiserLink.to_json( - resources.DisplayVideo360AdvertiserLink() - ) - req.return_value.content = return_value - request = analytics_admin.CreateDisplayVideo360AdvertiserLinkRequest() + request = analytics_admin.ArchiveCustomDimensionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DisplayVideo360AdvertiserLink() - post_with_metadata.return_value = ( - resources.DisplayVideo360AdvertiserLink(), - metadata, - ) - client.create_display_video360_advertiser_link( + client.archive_custom_dimension( request, metadata=[ ("key", "val"), @@ -100538,18 +106399,16 @@ def test_create_display_video360_advertiser_link_rest_interceptors(null_intercep ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_delete_display_video360_advertiser_link_rest_bad_request( - request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, +def test_get_custom_dimension_rest_bad_request( + request_type=analytics_admin.GetCustomDimensionRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/sample2"} + request_init = {"name": "properties/sample1/customDimensions/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -100564,45 +106423,61 @@ def test_delete_display_video360_advertiser_link_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_display_video360_advertiser_link(request) + client.get_custom_dimension(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest, + analytics_admin.GetCustomDimensionRequest, dict, ], ) -def test_delete_display_video360_advertiser_link_rest_call_success(request_type): +def test_get_custom_dimension_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/displayVideo360AdvertiserLinks/sample2"} + request_init = {"name": "properties/sample1/customDimensions/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.CustomDimension( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + scope=resources.CustomDimension.DimensionScope.EVENT, + disallow_ads_personalization=True, + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.CustomDimension.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_display_video360_advertiser_link(request) + response = client.get_custom_dimension(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.CustomDimension) + assert response.name == "name_value" + assert response.parameter_name == "parameter_name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.scope == resources.CustomDimension.DimensionScope.EVENT + assert response.disallow_ads_personalization is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_display_video360_advertiser_link_rest_interceptors(null_interceptor): +def test_get_custom_dimension_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -100616,12 +106491,18 @@ def test_delete_display_video360_advertiser_link_rest_interceptors(null_intercep ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "post_get_custom_dimension" + ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_delete_display_video360_advertiser_link", + "post_get_custom_dimension_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_custom_dimension" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest.pb( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetCustomDimensionRequest.pb( + analytics_admin.GetCustomDimensionRequest() ) transcode.return_value = { "method": "post", @@ -100633,15 +106514,19 @@ def test_delete_display_video360_advertiser_link_rest_interceptors(null_intercep 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.CustomDimension.to_json(resources.CustomDimension()) + req.return_value.content = return_value - request = analytics_admin.DeleteDisplayVideo360AdvertiserLinkRequest() + request = analytics_admin.GetCustomDimensionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.CustomDimension() + post_with_metadata.return_value = resources.CustomDimension(), metadata - client.delete_display_video360_advertiser_link( + client.get_custom_dimension( request, metadata=[ ("key", "val"), @@ -100650,20 +106535,18 @@ def test_delete_display_video360_advertiser_link_rest_interceptors(null_intercep ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_update_display_video360_advertiser_link_rest_bad_request( - request_type=analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, +def test_create_custom_metric_rest_bad_request( + request_type=analytics_admin.CreateCustomMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "display_video_360_advertiser_link": { - "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" - } - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -100678,43 +106561,38 @@ def test_update_display_video360_advertiser_link_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_display_video360_advertiser_link(request) + client.create_custom_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest, + analytics_admin.CreateCustomMetricRequest, dict, ], ) -def test_update_display_video360_advertiser_link_rest_call_success(request_type): +def test_create_custom_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "display_video_360_advertiser_link": { - "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2" - } - } - request_init["display_video_360_advertiser_link"] = { - "name": "properties/sample1/displayVideo360AdvertiserLinks/sample2", - "advertiser_id": "advertiser_id_value", - "advertiser_display_name": "advertiser_display_name_value", - "ads_personalization_enabled": {"value": True}, - "campaign_data_sharing_enabled": {}, - "cost_data_sharing_enabled": {}, + request_init = {"parent": "properties/sample1"} + request_init["custom_metric"] = { + "name": "name_value", + "parameter_name": "parameter_name_value", + "display_name": "display_name_value", + "description": "description_value", + "measurement_unit": 1, + "scope": 1, + "restricted_metric_type": [1], } # 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 = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest.meta.fields[ - "display_video_360_advertiser_link" - ] + test_field = analytics_admin.CreateCustomMetricRequest.meta.fields["custom_metric"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -100742,9 +106620,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init[ - "display_video_360_advertiser_link" - ].items(): # pragma: NO COVER + for field, value in request_init["custom_metric"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -100774,23 +106650,25 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range( - 0, len(request_init["display_video_360_advertiser_link"][field]) - ): - del request_init["display_video_360_advertiser_link"][field][i][ - subfield - ] + for i in range(0, len(request_init["custom_metric"][field])): + del request_init["custom_metric"][field][i][subfield] else: - del request_init["display_video_360_advertiser_link"][field][subfield] + del request_init["custom_metric"][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 = resources.DisplayVideo360AdvertiserLink( + return_value = resources.CustomMetric( name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, + scope=resources.CustomMetric.MetricScope.EVENT, + restricted_metric_type=[ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ], ) # Wrap the value into a proper Response obj @@ -100798,22 +106676,28 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLink.pb(return_value) + return_value = resources.CustomMetric.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_display_video360_advertiser_link(request) + response = client.create_custom_metric(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DisplayVideo360AdvertiserLink) + assert isinstance(response, resources.CustomMetric) assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" + assert response.parameter_name == "parameter_name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.measurement_unit == resources.CustomMetric.MeasurementUnit.STANDARD + assert response.scope == resources.CustomMetric.MetricScope.EVENT + assert response.restricted_metric_type == [ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_display_video360_advertiser_link_rest_interceptors(null_interceptor): +def test_create_custom_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -100827,20 +106711,18 @@ def test_update_display_video360_advertiser_link_rest_interceptors(null_intercep ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_display_video360_advertiser_link", + transports.AnalyticsAdminServiceRestInterceptor, "post_create_custom_metric" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_display_video360_advertiser_link_with_metadata", + "post_create_custom_metric_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_display_video360_advertiser_link", + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_custom_metric" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest.pb( - analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() + pb_message = analytics_admin.CreateCustomMetricRequest.pb( + analytics_admin.CreateCustomMetricRequest() ) transcode.return_value = { "method": "post", @@ -100852,24 +106734,19 @@ def test_update_display_video360_advertiser_link_rest_interceptors(null_intercep 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.DisplayVideo360AdvertiserLink.to_json( - resources.DisplayVideo360AdvertiserLink() - ) + return_value = resources.CustomMetric.to_json(resources.CustomMetric()) req.return_value.content = return_value - request = analytics_admin.UpdateDisplayVideo360AdvertiserLinkRequest() + request = analytics_admin.CreateCustomMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DisplayVideo360AdvertiserLink() - post_with_metadata.return_value = ( - resources.DisplayVideo360AdvertiserLink(), - metadata, - ) + post.return_value = resources.CustomMetric() + post_with_metadata.return_value = resources.CustomMetric(), metadata - client.update_display_video360_advertiser_link( + client.create_custom_metric( request, metadata=[ ("key", "val"), @@ -100882,15 +106759,15 @@ def test_update_display_video360_advertiser_link_rest_interceptors(null_intercep post_with_metadata.assert_called_once() -def test_get_display_video360_advertiser_link_proposal_rest_bad_request( - request_type=analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, +def test_update_custom_metric_rest_bad_request( + request_type=analytics_admin.UpdateCustomMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + "custom_metric": {"name": "properties/sample1/customMetrics/sample2"} } request = request_type(**request_init) @@ -100906,35 +106783,116 @@ def test_get_display_video360_advertiser_link_proposal_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_display_video360_advertiser_link_proposal(request) + client.update_custom_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest, + analytics_admin.UpdateCustomMetricRequest, dict, ], ) -def test_get_display_video360_advertiser_link_proposal_rest_call_success(request_type): +def test_update_custom_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + "custom_metric": {"name": "properties/sample1/customMetrics/sample2"} + } + request_init["custom_metric"] = { + "name": "properties/sample1/customMetrics/sample2", + "parameter_name": "parameter_name_value", + "display_name": "display_name_value", + "description": "description_value", + "measurement_unit": 1, + "scope": 1, + "restricted_metric_type": [1], } + # 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 = analytics_admin.UpdateCustomMetricRequest.meta.fields["custom_metric"] + + 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["custom_metric"].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["custom_metric"][field])): + del request_init["custom_metric"][field][i][subfield] + else: + del request_init["custom_metric"][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 = resources.DisplayVideo360AdvertiserLinkProposal( + return_value = resources.CustomMetric( name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - validation_email="validation_email_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, + scope=resources.CustomMetric.MetricScope.EVENT, + restricted_metric_type=[ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ], ) # Wrap the value into a proper Response obj @@ -100942,25 +106900,28 @@ def test_get_display_video360_advertiser_link_proposal_rest_call_success(request response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb(return_value) + return_value = resources.CustomMetric.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_display_video360_advertiser_link_proposal(request) + response = client.update_custom_metric(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DisplayVideo360AdvertiserLinkProposal) + assert isinstance(response, resources.CustomMetric) assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" - assert response.validation_email == "validation_email_value" + assert response.parameter_name == "parameter_name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.measurement_unit == resources.CustomMetric.MeasurementUnit.STANDARD + assert response.scope == resources.CustomMetric.MetricScope.EVENT + assert response.restricted_metric_type == [ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_display_video360_advertiser_link_proposal_rest_interceptors( - null_interceptor, -): +def test_update_custom_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -100974,20 +106935,18 @@ def test_get_display_video360_advertiser_link_proposal_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_display_video360_advertiser_link_proposal", + transports.AnalyticsAdminServiceRestInterceptor, "post_update_custom_metric" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_display_video360_advertiser_link_proposal_with_metadata", + "post_update_custom_metric_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_display_video360_advertiser_link_proposal", + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_custom_metric" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest.pb( - analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() + pb_message = analytics_admin.UpdateCustomMetricRequest.pb( + analytics_admin.UpdateCustomMetricRequest() ) transcode.return_value = { "method": "post", @@ -100999,24 +106958,19 @@ def test_get_display_video360_advertiser_link_proposal_rest_interceptors( 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.DisplayVideo360AdvertiserLinkProposal.to_json( - resources.DisplayVideo360AdvertiserLinkProposal() - ) + return_value = resources.CustomMetric.to_json(resources.CustomMetric()) req.return_value.content = return_value - request = analytics_admin.GetDisplayVideo360AdvertiserLinkProposalRequest() + request = analytics_admin.UpdateCustomMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DisplayVideo360AdvertiserLinkProposal() - post_with_metadata.return_value = ( - resources.DisplayVideo360AdvertiserLinkProposal(), - metadata, - ) + post.return_value = resources.CustomMetric() + post_with_metadata.return_value = resources.CustomMetric(), metadata - client.get_display_video360_advertiser_link_proposal( + client.update_custom_metric( request, metadata=[ ("key", "val"), @@ -101029,8 +106983,8 @@ def test_get_display_video360_advertiser_link_proposal_rest_interceptors( post_with_metadata.assert_called_once() -def test_list_display_video360_advertiser_link_proposals_rest_bad_request( - request_type=analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, +def test_list_custom_metrics_rest_bad_request( + request_type=analytics_admin.ListCustomMetricsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -101051,19 +107005,17 @@ def test_list_display_video360_advertiser_link_proposals_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.list_display_video360_advertiser_link_proposals(request) + client.list_custom_metrics(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest, + analytics_admin.ListCustomMetricsRequest, dict, ], ) -def test_list_display_video360_advertiser_link_proposals_rest_call_success( - request_type, -): +def test_list_custom_metrics_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -101075,10 +107027,8 @@ def test_list_display_video360_advertiser_link_proposals_rest_call_success( # 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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse( - next_page_token="next_page_token_value", - ) + return_value = analytics_admin.ListCustomMetricsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -101086,26 +107036,20 @@ def test_list_display_video360_advertiser_link_proposals_rest_call_success( response_value.status_code = 200 # Convert return value to protobuf type - return_value = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.pb( - return_value - ) - ) + return_value = analytics_admin.ListCustomMetricsResponse.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_display_video360_advertiser_link_proposals(request) + response = client.list_custom_metrics(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListDisplayVideo360AdvertiserLinkProposalsPager) + assert isinstance(response, pagers.ListCustomMetricsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_display_video360_advertiser_link_proposals_rest_interceptors( - null_interceptor, -): +def test_list_custom_metrics_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -101119,22 +107063,18 @@ def test_list_display_video360_advertiser_link_proposals_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_list_display_video360_advertiser_link_proposals", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_custom_metrics" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_display_video360_advertiser_link_proposals_with_metadata", + "post_list_custom_metrics_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_list_display_video360_advertiser_link_proposals", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_custom_metrics" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest.pb( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() - ) + pb_message = analytics_admin.ListCustomMetricsRequest.pb( + analytics_admin.ListCustomMetricsRequest() ) transcode.return_value = { "method": "post", @@ -101146,28 +107086,24 @@ def test_list_display_video360_advertiser_link_proposals_rest_interceptors( 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 = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse.to_json( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() - ) + return_value = analytics_admin.ListCustomMetricsResponse.to_json( + analytics_admin.ListCustomMetricsResponse() ) req.return_value.content = return_value - request = analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsRequest() + request = analytics_admin.ListCustomMetricsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse() - ) + post.return_value = analytics_admin.ListCustomMetricsResponse() post_with_metadata.return_value = ( - analytics_admin.ListDisplayVideo360AdvertiserLinkProposalsResponse(), + analytics_admin.ListCustomMetricsResponse(), metadata, ) - client.list_display_video360_advertiser_link_proposals( + client.list_custom_metrics( request, metadata=[ ("key", "val"), @@ -101180,14 +107116,14 @@ def test_list_display_video360_advertiser_link_proposals_rest_interceptors( post_with_metadata.assert_called_once() -def test_create_display_video360_advertiser_link_proposal_rest_bad_request( - request_type=analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, +def test_archive_custom_metric_rest_bad_request( + request_type=analytics_admin.ArchiveCustomMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"name": "properties/sample1/customMetrics/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -101202,159 +107138,45 @@ def test_create_display_video360_advertiser_link_proposal_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_display_video360_advertiser_link_proposal(request) + client.archive_custom_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest, + analytics_admin.ArchiveCustomMetricRequest, dict, ], ) -def test_create_display_video360_advertiser_link_proposal_rest_call_success( - request_type, -): +def test_archive_custom_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["display_video_360_advertiser_link_proposal"] = { - "name": "name_value", - "advertiser_id": "advertiser_id_value", - "link_proposal_status_details": { - "link_proposal_initiating_product": 1, - "requestor_email": "requestor_email_value", - "link_proposal_state": 1, - }, - "advertiser_display_name": "advertiser_display_name_value", - "validation_email": "validation_email_value", - "ads_personalization_enabled": {"value": True}, - "campaign_data_sharing_enabled": {}, - "cost_data_sharing_enabled": {}, - } - # 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 = ( - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest.meta.fields[ - "display_video_360_advertiser_link_proposal" - ] - ) - - 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[ - "display_video_360_advertiser_link_proposal" - ].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["display_video_360_advertiser_link_proposal"][ - field - ] - ), - ): - del request_init["display_video_360_advertiser_link_proposal"][ - field - ][i][subfield] - else: - del request_init["display_video_360_advertiser_link_proposal"][field][ - subfield - ] + request_init = {"name": "properties/sample1/customMetrics/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 = resources.DisplayVideo360AdvertiserLinkProposal( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - validation_email="validation_email_value", - ) + return_value = None # 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.DisplayVideo360AdvertiserLinkProposal.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"} - response = client.create_display_video360_advertiser_link_proposal(request) + response = client.archive_custom_metric(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DisplayVideo360AdvertiserLinkProposal) - assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" - assert response.validation_email == "validation_email_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_display_video360_advertiser_link_proposal_rest_interceptors( - null_interceptor, -): +def test_archive_custom_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -101368,22 +107190,11 @@ def test_create_display_video360_advertiser_link_proposal_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_display_video360_advertiser_link_proposal", - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_display_video360_advertiser_link_proposal_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_create_display_video360_advertiser_link_proposal", + transports.AnalyticsAdminServiceRestInterceptor, "pre_archive_custom_metric" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = ( - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest.pb( - analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() - ) + pb_message = analytics_admin.ArchiveCustomMetricRequest.pb( + analytics_admin.ArchiveCustomMetricRequest() ) transcode.return_value = { "method": "post", @@ -101395,24 +107206,15 @@ def test_create_display_video360_advertiser_link_proposal_rest_interceptors( 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.DisplayVideo360AdvertiserLinkProposal.to_json( - resources.DisplayVideo360AdvertiserLinkProposal() - ) - req.return_value.content = return_value - request = analytics_admin.CreateDisplayVideo360AdvertiserLinkProposalRequest() + request = analytics_admin.ArchiveCustomMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DisplayVideo360AdvertiserLinkProposal() - post_with_metadata.return_value = ( - resources.DisplayVideo360AdvertiserLinkProposal(), - metadata, - ) - client.create_display_video360_advertiser_link_proposal( + client.archive_custom_metric( request, metadata=[ ("key", "val"), @@ -101421,20 +107223,16 @@ def test_create_display_video360_advertiser_link_proposal_rest_interceptors( ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_delete_display_video360_advertiser_link_proposal_rest_bad_request( - request_type=analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, +def test_get_custom_metric_rest_bad_request( + request_type=analytics_admin.GetCustomMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" - } + request_init = {"name": "properties/sample1/customMetrics/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -101449,51 +107247,67 @@ def test_delete_display_video360_advertiser_link_proposal_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_display_video360_advertiser_link_proposal(request) + client.get_custom_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest, + analytics_admin.GetCustomMetricRequest, dict, ], ) -def test_delete_display_video360_advertiser_link_proposal_rest_call_success( - request_type, -): +def test_get_custom_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" - } + request_init = {"name": "properties/sample1/customMetrics/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.CustomMetric( + name="name_value", + parameter_name="parameter_name_value", + display_name="display_name_value", + description="description_value", + measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, + scope=resources.CustomMetric.MetricScope.EVENT, + restricted_metric_type=[ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ], + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.CustomMetric.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_display_video360_advertiser_link_proposal(request) + response = client.get_custom_metric(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.CustomMetric) + assert response.name == "name_value" + assert response.parameter_name == "parameter_name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.measurement_unit == resources.CustomMetric.MeasurementUnit.STANDARD + assert response.scope == resources.CustomMetric.MetricScope.EVENT + assert response.restricted_metric_type == [ + resources.CustomMetric.RestrictedMetricType.COST_DATA + ] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_display_video360_advertiser_link_proposal_rest_interceptors( - null_interceptor, -): +def test_get_custom_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -101507,14 +107321,18 @@ def test_delete_display_video360_advertiser_link_proposal_rest_interceptors( ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "post_get_custom_metric" + ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_delete_display_video360_advertiser_link_proposal", + "post_get_custom_metric_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_custom_metric" ) as pre: pre.assert_not_called() - pb_message = ( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest.pb( - analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() - ) + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetCustomMetricRequest.pb( + analytics_admin.GetCustomMetricRequest() ) transcode.return_value = { "method": "post", @@ -101526,15 +107344,19 @@ def test_delete_display_video360_advertiser_link_proposal_rest_interceptors( 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.CustomMetric.to_json(resources.CustomMetric()) + req.return_value.content = return_value - request = analytics_admin.DeleteDisplayVideo360AdvertiserLinkProposalRequest() + request = analytics_admin.GetCustomMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.CustomMetric() + post_with_metadata.return_value = resources.CustomMetric(), metadata - client.delete_display_video360_advertiser_link_proposal( + client.get_custom_metric( request, metadata=[ ("key", "val"), @@ -101543,18 +107365,18 @@ def test_delete_display_video360_advertiser_link_proposal_rest_interceptors( ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_approve_display_video360_advertiser_link_proposal_rest_bad_request( - request_type=analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, +def test_get_data_retention_settings_rest_bad_request( + request_type=analytics_admin.GetDataRetentionSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" - } + request_init = {"name": "properties/sample1/dataRetentionSettings"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -101569,34 +107391,33 @@ def test_approve_display_video360_advertiser_link_proposal_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.approve_display_video360_advertiser_link_proposal(request) + client.get_data_retention_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest, + analytics_admin.GetDataRetentionSettingsRequest, dict, ], ) -def test_approve_display_video360_advertiser_link_proposal_rest_call_success( - request_type, -): +def test_get_data_retention_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" - } + request_init = {"name": "properties/sample1/dataRetentionSettings"} 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 = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + return_value = resources.DataRetentionSettings( + name="name_value", + event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + reset_user_data_on_new_activity=True, ) # Wrap the value into a proper Response obj @@ -101604,27 +107425,29 @@ def test_approve_display_video360_advertiser_link_proposal_rest_call_success( response_value.status_code = 200 # Convert return value to protobuf type - return_value = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse.pb( - return_value - ) - ) + return_value = resources.DataRetentionSettings.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.approve_display_video360_advertiser_link_proposal(request) + response = client.get_data_retention_settings(request) # Establish that the response is the type that we expect. - assert isinstance( - response, analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse + assert isinstance(response, resources.DataRetentionSettings) + assert response.name == "name_value" + assert ( + response.event_data_retention + == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS ) + assert ( + response.user_data_retention + == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS + ) + assert response.reset_user_data_on_new_activity is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_approve_display_video360_advertiser_link_proposal_rest_interceptors( - null_interceptor, -): +def test_get_data_retention_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -101639,21 +107462,19 @@ def test_approve_display_video360_advertiser_link_proposal_rest_interceptors( path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_approve_display_video360_advertiser_link_proposal", + "post_get_data_retention_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_approve_display_video360_advertiser_link_proposal_with_metadata", + "post_get_data_retention_settings_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_approve_display_video360_advertiser_link_proposal", + "pre_get_data_retention_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest.pb( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() - ) + pb_message = analytics_admin.GetDataRetentionSettingsRequest.pb( + analytics_admin.GetDataRetentionSettingsRequest() ) transcode.return_value = { "method": "post", @@ -101665,26 +107486,21 @@ def test_approve_display_video360_advertiser_link_proposal_rest_interceptors( 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 = analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse.to_json( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() + return_value = resources.DataRetentionSettings.to_json( + resources.DataRetentionSettings() ) req.return_value.content = return_value - request = analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalRequest() + request = analytics_admin.GetDataRetentionSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse() - ) - post_with_metadata.return_value = ( - analytics_admin.ApproveDisplayVideo360AdvertiserLinkProposalResponse(), - metadata, - ) + post.return_value = resources.DataRetentionSettings() + post_with_metadata.return_value = resources.DataRetentionSettings(), metadata - client.approve_display_video360_advertiser_link_proposal( + client.get_data_retention_settings( request, metadata=[ ("key", "val"), @@ -101697,15 +107513,15 @@ def test_approve_display_video360_advertiser_link_proposal_rest_interceptors( post_with_metadata.assert_called_once() -def test_cancel_display_video360_advertiser_link_proposal_rest_bad_request( - request_type=analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, +def test_update_data_retention_settings_rest_bad_request( + request_type=analytics_admin.UpdateDataRetentionSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + "data_retention_settings": {"name": "properties/sample1/dataRetentionSettings"} } request = request_type(**request_init) @@ -101721,37 +107537,112 @@ def test_cancel_display_video360_advertiser_link_proposal_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.cancel_display_video360_advertiser_link_proposal(request) + client.update_data_retention_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest, + analytics_admin.UpdateDataRetentionSettingsRequest, dict, ], ) -def test_cancel_display_video360_advertiser_link_proposal_rest_call_success( - request_type, -): +def test_update_data_retention_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/displayVideo360AdvertiserLinkProposals/sample2" + "data_retention_settings": {"name": "properties/sample1/dataRetentionSettings"} + } + request_init["data_retention_settings"] = { + "name": "properties/sample1/dataRetentionSettings", + "event_data_retention": 1, + "user_data_retention": 1, + "reset_user_data_on_new_activity": True, } + # 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 = analytics_admin.UpdateDataRetentionSettingsRequest.meta.fields[ + "data_retention_settings" + ] + + 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[ + "data_retention_settings" + ].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["data_retention_settings"][field])): + del request_init["data_retention_settings"][field][i][subfield] + else: + del request_init["data_retention_settings"][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 = resources.DisplayVideo360AdvertiserLinkProposal( + return_value = resources.DataRetentionSettings( name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - validation_email="validation_email_value", + event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, + reset_user_data_on_new_activity=True, ) # Wrap the value into a proper Response obj @@ -101759,25 +107650,29 @@ def test_cancel_display_video360_advertiser_link_proposal_rest_call_success( response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DisplayVideo360AdvertiserLinkProposal.pb(return_value) + return_value = resources.DataRetentionSettings.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.cancel_display_video360_advertiser_link_proposal(request) + response = client.update_data_retention_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DisplayVideo360AdvertiserLinkProposal) + assert isinstance(response, resources.DataRetentionSettings) assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" - assert response.validation_email == "validation_email_value" + assert ( + response.event_data_retention + == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS + ) + assert ( + response.user_data_retention + == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS + ) + assert response.reset_user_data_on_new_activity is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_cancel_display_video360_advertiser_link_proposal_rest_interceptors( - null_interceptor, -): +def test_update_data_retention_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -101792,21 +107687,19 @@ def test_cancel_display_video360_advertiser_link_proposal_rest_interceptors( path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_cancel_display_video360_advertiser_link_proposal", + "post_update_data_retention_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_cancel_display_video360_advertiser_link_proposal_with_metadata", + "post_update_data_retention_settings_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_cancel_display_video360_advertiser_link_proposal", + "pre_update_data_retention_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = ( - analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest.pb( - analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() - ) + pb_message = analytics_admin.UpdateDataRetentionSettingsRequest.pb( + analytics_admin.UpdateDataRetentionSettingsRequest() ) transcode.return_value = { "method": "post", @@ -101818,24 +107711,21 @@ def test_cancel_display_video360_advertiser_link_proposal_rest_interceptors( 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.DisplayVideo360AdvertiserLinkProposal.to_json( - resources.DisplayVideo360AdvertiserLinkProposal() + return_value = resources.DataRetentionSettings.to_json( + resources.DataRetentionSettings() ) req.return_value.content = return_value - request = analytics_admin.CancelDisplayVideo360AdvertiserLinkProposalRequest() + request = analytics_admin.UpdateDataRetentionSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DisplayVideo360AdvertiserLinkProposal() - post_with_metadata.return_value = ( - resources.DisplayVideo360AdvertiserLinkProposal(), - metadata, - ) + post.return_value = resources.DataRetentionSettings() + post_with_metadata.return_value = resources.DataRetentionSettings(), metadata - client.cancel_display_video360_advertiser_link_proposal( + client.update_data_retention_settings( request, metadata=[ ("key", "val"), @@ -101848,8 +107738,8 @@ def test_cancel_display_video360_advertiser_link_proposal_rest_interceptors( post_with_metadata.assert_called_once() -def test_create_custom_dimension_rest_bad_request( - request_type=analytics_admin.CreateCustomDimensionRequest, +def test_create_data_stream_rest_bad_request( + request_type=analytics_admin.CreateDataStreamRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -101870,39 +107760,49 @@ def test_create_custom_dimension_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_custom_dimension(request) + client.create_data_stream(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateCustomDimensionRequest, + analytics_admin.CreateDataStreamRequest, dict, ], ) -def test_create_custom_dimension_rest_call_success(request_type): +def test_create_data_stream_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["custom_dimension"] = { + request_init["data_stream"] = { + "web_stream_data": { + "measurement_id": "measurement_id_value", + "firebase_app_id": "firebase_app_id_value", + "default_uri": "default_uri_value", + }, + "android_app_stream_data": { + "firebase_app_id": "firebase_app_id_value", + "package_name": "package_name_value", + }, + "ios_app_stream_data": { + "firebase_app_id": "firebase_app_id_value", + "bundle_id": "bundle_id_value", + }, "name": "name_value", - "parameter_name": "parameter_name_value", + "type_": 1, "display_name": "display_name_value", - "description": "description_value", - "scope": 1, - "disallow_ads_personalization": True, + "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 = analytics_admin.CreateCustomDimensionRequest.meta.fields[ - "custom_dimension" - ] + test_field = analytics_admin.CreateDataStreamRequest.meta.fields["data_stream"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -101930,7 +107830,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["custom_dimension"].items(): # pragma: NO COVER + for field, value in request_init["data_stream"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -101960,22 +107860,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["custom_dimension"][field])): - del request_init["custom_dimension"][field][i][subfield] + for i in range(0, len(request_init["data_stream"][field])): + del request_init["data_stream"][field][i][subfield] else: - del request_init["custom_dimension"][field][subfield] + del request_init["data_stream"][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 = resources.CustomDimension( + return_value = resources.DataStream( name="name_value", - parameter_name="parameter_name_value", + type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, display_name="display_name_value", - description="description_value", - scope=resources.CustomDimension.DimensionScope.EVENT, - disallow_ads_personalization=True, ) # Wrap the value into a proper Response obj @@ -101983,25 +107880,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomDimension.pb(return_value) + return_value = resources.DataStream.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.create_custom_dimension(request) + response = client.create_data_stream(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CustomDimension) + assert isinstance(response, resources.DataStream) assert response.name == "name_value" - assert response.parameter_name == "parameter_name_value" + assert response.type_ == resources.DataStream.DataStreamType.WEB_DATA_STREAM assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.scope == resources.CustomDimension.DimensionScope.EVENT - assert response.disallow_ads_personalization is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_custom_dimension_rest_interceptors(null_interceptor): +def test_create_data_stream_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -102015,18 +107909,18 @@ def test_create_custom_dimension_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_data_stream" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_custom_dimension_with_metadata", + "post_create_data_stream_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_data_stream" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateCustomDimensionRequest.pb( - analytics_admin.CreateCustomDimensionRequest() + pb_message = analytics_admin.CreateDataStreamRequest.pb( + analytics_admin.CreateDataStreamRequest() ) transcode.return_value = { "method": "post", @@ -102038,19 +107932,19 @@ def test_create_custom_dimension_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.CustomDimension.to_json(resources.CustomDimension()) + return_value = resources.DataStream.to_json(resources.DataStream()) req.return_value.content = return_value - request = analytics_admin.CreateCustomDimensionRequest() + request = analytics_admin.CreateDataStreamRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CustomDimension() - post_with_metadata.return_value = resources.CustomDimension(), metadata + post.return_value = resources.DataStream() + post_with_metadata.return_value = resources.DataStream(), metadata - client.create_custom_dimension( + client.create_data_stream( request, metadata=[ ("key", "val"), @@ -102063,16 +107957,14 @@ def test_create_custom_dimension_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_custom_dimension_rest_bad_request( - request_type=analytics_admin.UpdateCustomDimensionRequest, +def test_delete_data_stream_rest_bad_request( + request_type=analytics_admin.DeleteDataStreamRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "custom_dimension": {"name": "properties/sample1/customDimensions/sample2"} - } + request_init = {"name": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -102087,41 +107979,158 @@ def test_update_custom_dimension_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_custom_dimension(request) + client.delete_data_stream(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateCustomDimensionRequest, + analytics_admin.DeleteDataStreamRequest, dict, ], ) -def test_update_custom_dimension_rest_call_success(request_type): +def test_delete_data_stream_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "custom_dimension": {"name": "properties/sample1/customDimensions/sample2"} - } - request_init["custom_dimension"] = { - "name": "properties/sample1/customDimensions/sample2", - "parameter_name": "parameter_name_value", + request_init = {"name": "properties/sample1/dataStreams/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = 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_data_stream(request) + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_data_stream_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "pre_delete_data_stream" + ) as pre: + pre.assert_not_called() + pb_message = analytics_admin.DeleteDataStreamRequest.pb( + analytics_admin.DeleteDataStreamRequest() + ) + 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"} + + request = analytics_admin.DeleteDataStreamRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + + client.delete_data_stream( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + + +def test_update_data_stream_rest_bad_request( + request_type=analytics_admin.UpdateDataStreamRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"data_stream": {"name": "properties/sample1/dataStreams/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.update_data_stream(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.UpdateDataStreamRequest, + dict, + ], +) +def test_update_data_stream_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"data_stream": {"name": "properties/sample1/dataStreams/sample2"}} + request_init["data_stream"] = { + "web_stream_data": { + "measurement_id": "measurement_id_value", + "firebase_app_id": "firebase_app_id_value", + "default_uri": "default_uri_value", + }, + "android_app_stream_data": { + "firebase_app_id": "firebase_app_id_value", + "package_name": "package_name_value", + }, + "ios_app_stream_data": { + "firebase_app_id": "firebase_app_id_value", + "bundle_id": "bundle_id_value", + }, + "name": "properties/sample1/dataStreams/sample2", + "type_": 1, "display_name": "display_name_value", - "description": "description_value", - "scope": 1, - "disallow_ads_personalization": True, + "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 = analytics_admin.UpdateCustomDimensionRequest.meta.fields[ - "custom_dimension" - ] + test_field = analytics_admin.UpdateDataStreamRequest.meta.fields["data_stream"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -102149,7 +108158,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["custom_dimension"].items(): # pragma: NO COVER + for field, value in request_init["data_stream"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -102179,22 +108188,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["custom_dimension"][field])): - del request_init["custom_dimension"][field][i][subfield] + for i in range(0, len(request_init["data_stream"][field])): + del request_init["data_stream"][field][i][subfield] else: - del request_init["custom_dimension"][field][subfield] + del request_init["data_stream"][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 = resources.CustomDimension( + return_value = resources.DataStream( name="name_value", - parameter_name="parameter_name_value", + type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, display_name="display_name_value", - description="description_value", - scope=resources.CustomDimension.DimensionScope.EVENT, - disallow_ads_personalization=True, ) # Wrap the value into a proper Response obj @@ -102202,25 +108208,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomDimension.pb(return_value) + return_value = resources.DataStream.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_custom_dimension(request) + response = client.update_data_stream(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CustomDimension) + assert isinstance(response, resources.DataStream) assert response.name == "name_value" - assert response.parameter_name == "parameter_name_value" + assert response.type_ == resources.DataStream.DataStreamType.WEB_DATA_STREAM assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.scope == resources.CustomDimension.DimensionScope.EVENT - assert response.disallow_ads_personalization is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_custom_dimension_rest_interceptors(null_interceptor): +def test_update_data_stream_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -102234,18 +108237,18 @@ def test_update_custom_dimension_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_data_stream" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_custom_dimension_with_metadata", + "post_update_data_stream_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_data_stream" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateCustomDimensionRequest.pb( - analytics_admin.UpdateCustomDimensionRequest() + pb_message = analytics_admin.UpdateDataStreamRequest.pb( + analytics_admin.UpdateDataStreamRequest() ) transcode.return_value = { "method": "post", @@ -102257,19 +108260,19 @@ def test_update_custom_dimension_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.CustomDimension.to_json(resources.CustomDimension()) + return_value = resources.DataStream.to_json(resources.DataStream()) req.return_value.content = return_value - request = analytics_admin.UpdateCustomDimensionRequest() + request = analytics_admin.UpdateDataStreamRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CustomDimension() - post_with_metadata.return_value = resources.CustomDimension(), metadata + post.return_value = resources.DataStream() + post_with_metadata.return_value = resources.DataStream(), metadata - client.update_custom_dimension( + client.update_data_stream( request, metadata=[ ("key", "val"), @@ -102282,8 +108285,8 @@ def test_update_custom_dimension_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_custom_dimensions_rest_bad_request( - request_type=analytics_admin.ListCustomDimensionsRequest, +def test_list_data_streams_rest_bad_request( + request_type=analytics_admin.ListDataStreamsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -102304,17 +108307,17 @@ def test_list_custom_dimensions_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.list_custom_dimensions(request) + client.list_data_streams(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListCustomDimensionsRequest, + analytics_admin.ListDataStreamsRequest, dict, ], ) -def test_list_custom_dimensions_rest_call_success(request_type): +def test_list_data_streams_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -102326,7 +108329,7 @@ def test_list_custom_dimensions_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListCustomDimensionsResponse( + return_value = analytics_admin.ListDataStreamsResponse( next_page_token="next_page_token_value", ) @@ -102335,20 +108338,20 @@ def test_list_custom_dimensions_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCustomDimensionsResponse.pb(return_value) + return_value = analytics_admin.ListDataStreamsResponse.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_custom_dimensions(request) + response = client.list_data_streams(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListCustomDimensionsPager) + assert isinstance(response, pagers.ListDataStreamsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_custom_dimensions_rest_interceptors(null_interceptor): +def test_list_data_streams_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -102362,18 +108365,18 @@ def test_list_custom_dimensions_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_custom_dimensions" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_data_streams" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_custom_dimensions_with_metadata", + "post_list_data_streams_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_custom_dimensions" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_data_streams" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListCustomDimensionsRequest.pb( - analytics_admin.ListCustomDimensionsRequest() + pb_message = analytics_admin.ListDataStreamsRequest.pb( + analytics_admin.ListDataStreamsRequest() ) transcode.return_value = { "method": "post", @@ -102385,24 +108388,24 @@ def test_list_custom_dimensions_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 = analytics_admin.ListCustomDimensionsResponse.to_json( - analytics_admin.ListCustomDimensionsResponse() + return_value = analytics_admin.ListDataStreamsResponse.to_json( + analytics_admin.ListDataStreamsResponse() ) req.return_value.content = return_value - request = analytics_admin.ListCustomDimensionsRequest() + request = analytics_admin.ListDataStreamsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListCustomDimensionsResponse() + post.return_value = analytics_admin.ListDataStreamsResponse() post_with_metadata.return_value = ( - analytics_admin.ListCustomDimensionsResponse(), + analytics_admin.ListDataStreamsResponse(), metadata, ) - client.list_custom_dimensions( + client.list_data_streams( request, metadata=[ ("key", "val"), @@ -102415,14 +108418,14 @@ def test_list_custom_dimensions_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_archive_custom_dimension_rest_bad_request( - request_type=analytics_admin.ArchiveCustomDimensionRequest, +def test_get_data_stream_rest_bad_request( + request_type=analytics_admin.GetDataStreamRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customDimensions/sample2"} + request_init = {"name": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -102437,45 +108440,55 @@ def test_archive_custom_dimension_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.archive_custom_dimension(request) + client.get_data_stream(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ArchiveCustomDimensionRequest, + analytics_admin.GetDataStreamRequest, dict, ], ) -def test_archive_custom_dimension_rest_call_success(request_type): +def test_get_data_stream_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customDimensions/sample2"} + request_init = {"name": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.DataStream( + name="name_value", + type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, + display_name="display_name_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.DataStream.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.archive_custom_dimension(request) + response = client.get_data_stream(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.DataStream) + assert response.name == "name_value" + assert response.type_ == resources.DataStream.DataStreamType.WEB_DATA_STREAM + assert response.display_name == "display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_archive_custom_dimension_rest_interceptors(null_interceptor): +def test_get_data_stream_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -102489,11 +108502,18 @@ def test_archive_custom_dimension_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_archive_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_data_stream" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_data_stream_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_data_stream" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.ArchiveCustomDimensionRequest.pb( - analytics_admin.ArchiveCustomDimensionRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetDataStreamRequest.pb( + analytics_admin.GetDataStreamRequest() ) transcode.return_value = { "method": "post", @@ -102505,15 +108525,19 @@ def test_archive_custom_dimension_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.DataStream.to_json(resources.DataStream()) + req.return_value.content = return_value - request = analytics_admin.ArchiveCustomDimensionRequest() + request = analytics_admin.GetDataStreamRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.DataStream() + post_with_metadata.return_value = resources.DataStream(), metadata - client.archive_custom_dimension( + client.get_data_stream( request, metadata=[ ("key", "val"), @@ -102522,16 +108546,16 @@ def test_archive_custom_dimension_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_get_custom_dimension_rest_bad_request( - request_type=analytics_admin.GetCustomDimensionRequest, -): +def test_get_audience_rest_bad_request(request_type=analytics_admin.GetAudienceRequest): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customDimensions/sample2"} + request_init = {"name": "properties/sample1/audiences/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -102546,35 +108570,35 @@ def test_get_custom_dimension_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_custom_dimension(request) + client.get_audience(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetCustomDimensionRequest, + analytics_admin.GetAudienceRequest, dict, ], ) -def test_get_custom_dimension_rest_call_success(request_type): +def test_get_audience_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customDimensions/sample2"} + request_init = {"name": "properties/sample1/audiences/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 = resources.CustomDimension( + return_value = audience.Audience( name="name_value", - parameter_name="parameter_name_value", display_name="display_name_value", description="description_value", - scope=resources.CustomDimension.DimensionScope.EVENT, - disallow_ads_personalization=True, + membership_duration_days=2561, + ads_personalization_enabled=True, + exclusion_duration_mode=audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, ) # Wrap the value into a proper Response obj @@ -102582,25 +108606,28 @@ def test_get_custom_dimension_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomDimension.pb(return_value) + return_value = audience.Audience.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_custom_dimension(request) + response = client.get_audience(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CustomDimension) + assert isinstance(response, audience.Audience) assert response.name == "name_value" - assert response.parameter_name == "parameter_name_value" assert response.display_name == "display_name_value" assert response.description == "description_value" - assert response.scope == resources.CustomDimension.DimensionScope.EVENT - assert response.disallow_ads_personalization is True + assert response.membership_duration_days == 2561 + assert response.ads_personalization_enabled is True + assert ( + response.exclusion_duration_mode + == audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_custom_dimension_rest_interceptors(null_interceptor): +def test_get_audience_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -102614,18 +108641,18 @@ def test_get_custom_dimension_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_audience" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_custom_dimension_with_metadata", + "post_get_audience_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_custom_dimension" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_audience" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetCustomDimensionRequest.pb( - analytics_admin.GetCustomDimensionRequest() + pb_message = analytics_admin.GetAudienceRequest.pb( + analytics_admin.GetAudienceRequest() ) transcode.return_value = { "method": "post", @@ -102637,19 +108664,19 @@ def test_get_custom_dimension_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.CustomDimension.to_json(resources.CustomDimension()) + return_value = audience.Audience.to_json(audience.Audience()) req.return_value.content = return_value - request = analytics_admin.GetCustomDimensionRequest() + request = analytics_admin.GetAudienceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CustomDimension() - post_with_metadata.return_value = resources.CustomDimension(), metadata + post.return_value = audience.Audience() + post_with_metadata.return_value = audience.Audience(), metadata - client.get_custom_dimension( + client.get_audience( request, metadata=[ ("key", "val"), @@ -102662,8 +108689,8 @@ def test_get_custom_dimension_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_custom_metric_rest_bad_request( - request_type=analytics_admin.CreateCustomMetricRequest, +def test_list_audiences_rest_bad_request( + request_type=analytics_admin.ListAudiencesRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -102684,114 +108711,30 @@ def test_create_custom_metric_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_custom_metric(request) + client.list_audiences(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateCustomMetricRequest, + analytics_admin.ListAudiencesRequest, dict, ], ) -def test_create_custom_metric_rest_call_success(request_type): +def test_list_audiences_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["custom_metric"] = { - "name": "name_value", - "parameter_name": "parameter_name_value", - "display_name": "display_name_value", - "description": "description_value", - "measurement_unit": 1, - "scope": 1, - "restricted_metric_type": [1], - } - # 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 = analytics_admin.CreateCustomMetricRequest.meta.fields["custom_metric"] - - 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["custom_metric"].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["custom_metric"][field])): - del request_init["custom_metric"][field][i][subfield] - else: - del request_init["custom_metric"][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 = resources.CustomMetric( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, - scope=resources.CustomMetric.MetricScope.EVENT, - restricted_metric_type=[ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ], + return_value = analytics_admin.ListAudiencesResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -102799,28 +108742,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CustomMetric.pb(return_value) + return_value = analytics_admin.ListAudiencesResponse.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.create_custom_metric(request) + response = client.list_audiences(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CustomMetric) - assert response.name == "name_value" - assert response.parameter_name == "parameter_name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.measurement_unit == resources.CustomMetric.MeasurementUnit.STANDARD - assert response.scope == resources.CustomMetric.MetricScope.EVENT - assert response.restricted_metric_type == [ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ] + assert isinstance(response, pagers.ListAudiencesPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_custom_metric_rest_interceptors(null_interceptor): +def test_list_audiences_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -102834,18 +108769,18 @@ def test_create_custom_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_custom_metric" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_audiences" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_custom_metric_with_metadata", + "post_list_audiences_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_custom_metric" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_audiences" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateCustomMetricRequest.pb( - analytics_admin.CreateCustomMetricRequest() + pb_message = analytics_admin.ListAudiencesRequest.pb( + analytics_admin.ListAudiencesRequest() ) transcode.return_value = { "method": "post", @@ -102857,19 +108792,24 @@ def test_create_custom_metric_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.CustomMetric.to_json(resources.CustomMetric()) + return_value = analytics_admin.ListAudiencesResponse.to_json( + analytics_admin.ListAudiencesResponse() + ) req.return_value.content = return_value - request = analytics_admin.CreateCustomMetricRequest() + request = analytics_admin.ListAudiencesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CustomMetric() - post_with_metadata.return_value = resources.CustomMetric(), metadata + post.return_value = analytics_admin.ListAudiencesResponse() + post_with_metadata.return_value = ( + analytics_admin.ListAudiencesResponse(), + metadata, + ) - client.create_custom_metric( + client.list_audiences( request, metadata=[ ("key", "val"), @@ -102882,16 +108822,14 @@ def test_create_custom_metric_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_custom_metric_rest_bad_request( - request_type=analytics_admin.UpdateCustomMetricRequest, +def test_create_audience_rest_bad_request( + request_type=analytics_admin.CreateAudienceRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "custom_metric": {"name": "properties/sample1/customMetrics/sample2"} - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -102906,40 +108844,90 @@ def test_update_custom_metric_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_custom_metric(request) + client.create_audience(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateCustomMetricRequest, + analytics_admin.CreateAudienceRequest, dict, ], ) -def test_update_custom_metric_rest_call_success(request_type): +def test_create_audience_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "custom_metric": {"name": "properties/sample1/customMetrics/sample2"} - } - request_init["custom_metric"] = { - "name": "properties/sample1/customMetrics/sample2", - "parameter_name": "parameter_name_value", + request_init = {"parent": "properties/sample1"} + request_init["audience"] = { + "name": "name_value", "display_name": "display_name_value", "description": "description_value", - "measurement_unit": 1, - "scope": 1, - "restricted_metric_type": [1], + "membership_duration_days": 2561, + "ads_personalization_enabled": True, + "event_trigger": {"event_name": "event_name_value", "log_condition": 1}, + "exclusion_duration_mode": 1, + "filter_clauses": [ + { + "simple_filter": { + "scope": 1, + "filter_expression": { + "and_group": {"filter_expressions": {}}, + "or_group": {}, + "not_expression": {}, + "dimension_or_metric_filter": { + "string_filter": { + "match_type": 1, + "value": "value_value", + "case_sensitive": True, + }, + "in_list_filter": { + "values": ["values_value1", "values_value2"], + "case_sensitive": True, + }, + "numeric_filter": { + "operation": 1, + "value": { + "int64_value": 1073, + "double_value": 0.12710000000000002, + }, + }, + "between_filter": {"from_value": {}, "to_value": {}}, + "field_name": "field_name_value", + "at_any_point_in_time": True, + "in_any_n_day_period": 1994, + }, + "event_filter": { + "event_name": "event_name_value", + "event_parameter_filter_expression": {}, + }, + }, + }, + "sequence_filter": { + "scope": 1, + "sequence_maximum_duration": {"seconds": 751, "nanos": 543}, + "sequence_steps": [ + { + "scope": 1, + "immediately_follows": True, + "constraint_duration": {}, + "filter_expression": {}, + } + ], + }, + "clause_type": 1, + } + ], + "create_time": {"seconds": 751, "nanos": 543}, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateCustomMetricRequest.meta.fields["custom_metric"] + test_field = analytics_admin.CreateAudienceRequest.meta.fields["audience"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -102967,7 +108955,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["custom_metric"].items(): # pragma: NO COVER + for field, value in request_init["audience"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -102989,169 +108977,30 @@ 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["custom_metric"][field])): - del request_init["custom_metric"][field][i][subfield] - else: - del request_init["custom_metric"][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 = resources.CustomMetric( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, - scope=resources.CustomMetric.MetricScope.EVENT, - restricted_metric_type=[ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ], - ) - - # 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.CustomMetric.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_custom_metric(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, resources.CustomMetric) - assert response.name == "name_value" - assert response.parameter_name == "parameter_name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.measurement_unit == resources.CustomMetric.MeasurementUnit.STANDARD - assert response.scope == resources.CustomMetric.MetricScope.EVENT - assert response.restricted_metric_type == [ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ] - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_custom_metric_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_update_custom_metric" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_custom_metric_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_custom_metric" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateCustomMetricRequest.pb( - analytics_admin.UpdateCustomMetricRequest() - ) - 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.CustomMetric.to_json(resources.CustomMetric()) - req.return_value.content = return_value - - request = analytics_admin.UpdateCustomMetricRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = resources.CustomMetric() - post_with_metadata.return_value = resources.CustomMetric(), metadata - - client.update_custom_metric( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() - - -def test_list_custom_metrics_rest_bad_request( - request_type=analytics_admin.ListCustomMetricsRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"parent": "properties/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.list_custom_metrics(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.ListCustomMetricsRequest, - dict, - ], -) -def test_list_custom_metrics_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + # 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["audience"][field])): + del request_init["audience"][field][i][subfield] + else: + del request_init["audience"][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 = analytics_admin.ListCustomMetricsResponse( - next_page_token="next_page_token_value", + return_value = gaa_audience.Audience( + name="name_value", + display_name="display_name_value", + description="description_value", + membership_duration_days=2561, + ads_personalization_enabled=True, + exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, ) # Wrap the value into a proper Response obj @@ -103159,20 +109008,28 @@ def test_list_custom_metrics_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListCustomMetricsResponse.pb(return_value) + return_value = gaa_audience.Audience.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_custom_metrics(request) + response = client.create_audience(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListCustomMetricsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, gaa_audience.Audience) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.membership_duration_days == 2561 + assert response.ads_personalization_enabled is True + assert ( + response.exclusion_duration_mode + == gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_custom_metrics_rest_interceptors(null_interceptor): +def test_create_audience_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -103186,18 +109043,18 @@ def test_list_custom_metrics_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_custom_metrics" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_audience" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_custom_metrics_with_metadata", + "post_create_audience_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_custom_metrics" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_audience" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListCustomMetricsRequest.pb( - analytics_admin.ListCustomMetricsRequest() + pb_message = analytics_admin.CreateAudienceRequest.pb( + analytics_admin.CreateAudienceRequest() ) transcode.return_value = { "method": "post", @@ -103209,24 +109066,19 @@ def test_list_custom_metrics_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 = analytics_admin.ListCustomMetricsResponse.to_json( - analytics_admin.ListCustomMetricsResponse() - ) + return_value = gaa_audience.Audience.to_json(gaa_audience.Audience()) req.return_value.content = return_value - request = analytics_admin.ListCustomMetricsRequest() + request = analytics_admin.CreateAudienceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListCustomMetricsResponse() - post_with_metadata.return_value = ( - analytics_admin.ListCustomMetricsResponse(), - metadata, - ) + post.return_value = gaa_audience.Audience() + post_with_metadata.return_value = gaa_audience.Audience(), metadata - client.list_custom_metrics( + client.create_audience( request, metadata=[ ("key", "val"), @@ -103239,14 +109091,14 @@ def test_list_custom_metrics_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_archive_custom_metric_rest_bad_request( - request_type=analytics_admin.ArchiveCustomMetricRequest, +def test_update_audience_rest_bad_request( + request_type=analytics_admin.UpdateAudienceRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customMetrics/sample2"} + request_init = {"audience": {"name": "properties/sample1/audiences/sample2"}} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -103261,45 +109113,192 @@ def test_archive_custom_metric_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.archive_custom_metric(request) + client.update_audience(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ArchiveCustomMetricRequest, + analytics_admin.UpdateAudienceRequest, dict, ], ) -def test_archive_custom_metric_rest_call_success(request_type): +def test_update_audience_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customMetrics/sample2"} + request_init = {"audience": {"name": "properties/sample1/audiences/sample2"}} + request_init["audience"] = { + "name": "properties/sample1/audiences/sample2", + "display_name": "display_name_value", + "description": "description_value", + "membership_duration_days": 2561, + "ads_personalization_enabled": True, + "event_trigger": {"event_name": "event_name_value", "log_condition": 1}, + "exclusion_duration_mode": 1, + "filter_clauses": [ + { + "simple_filter": { + "scope": 1, + "filter_expression": { + "and_group": {"filter_expressions": {}}, + "or_group": {}, + "not_expression": {}, + "dimension_or_metric_filter": { + "string_filter": { + "match_type": 1, + "value": "value_value", + "case_sensitive": True, + }, + "in_list_filter": { + "values": ["values_value1", "values_value2"], + "case_sensitive": True, + }, + "numeric_filter": { + "operation": 1, + "value": { + "int64_value": 1073, + "double_value": 0.12710000000000002, + }, + }, + "between_filter": {"from_value": {}, "to_value": {}}, + "field_name": "field_name_value", + "at_any_point_in_time": True, + "in_any_n_day_period": 1994, + }, + "event_filter": { + "event_name": "event_name_value", + "event_parameter_filter_expression": {}, + }, + }, + }, + "sequence_filter": { + "scope": 1, + "sequence_maximum_duration": {"seconds": 751, "nanos": 543}, + "sequence_steps": [ + { + "scope": 1, + "immediately_follows": True, + "constraint_duration": {}, + "filter_expression": {}, + } + ], + }, + "clause_type": 1, + } + ], + "create_time": {"seconds": 751, "nanos": 543}, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateAudienceRequest.meta.fields["audience"] + + 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["audience"].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["audience"][field])): + del request_init["audience"][field][i][subfield] + else: + del request_init["audience"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = gaa_audience.Audience( + name="name_value", + display_name="display_name_value", + description="description_value", + membership_duration_days=2561, + ads_personalization_enabled=True, + exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = gaa_audience.Audience.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.archive_custom_metric(request) + response = client.update_audience(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, gaa_audience.Audience) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.membership_duration_days == 2561 + assert response.ads_personalization_enabled is True + assert ( + response.exclusion_duration_mode + == gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_archive_custom_metric_rest_interceptors(null_interceptor): +def test_update_audience_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -103313,11 +109312,18 @@ def test_archive_custom_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_archive_custom_metric" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_audience" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_audience_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_audience" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.ArchiveCustomMetricRequest.pb( - analytics_admin.ArchiveCustomMetricRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdateAudienceRequest.pb( + analytics_admin.UpdateAudienceRequest() ) transcode.return_value = { "method": "post", @@ -103329,15 +109335,19 @@ def test_archive_custom_metric_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 = gaa_audience.Audience.to_json(gaa_audience.Audience()) + req.return_value.content = return_value - request = analytics_admin.ArchiveCustomMetricRequest() + request = analytics_admin.UpdateAudienceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = gaa_audience.Audience() + post_with_metadata.return_value = gaa_audience.Audience(), metadata - client.archive_custom_metric( + client.update_audience( request, metadata=[ ("key", "val"), @@ -103346,16 +109356,18 @@ def test_archive_custom_metric_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_get_custom_metric_rest_bad_request( - request_type=analytics_admin.GetCustomMetricRequest, +def test_archive_audience_rest_bad_request( + request_type=analytics_admin.ArchiveAudienceRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customMetrics/sample2"} + request_init = {"name": "properties/sample1/audiences/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -103370,67 +109382,45 @@ def test_get_custom_metric_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_custom_metric(request) + client.archive_audience(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetCustomMetricRequest, + analytics_admin.ArchiveAudienceRequest, dict, ], ) -def test_get_custom_metric_rest_call_success(request_type): +def test_archive_audience_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/customMetrics/sample2"} + request_init = {"name": "properties/sample1/audiences/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 = resources.CustomMetric( - name="name_value", - parameter_name="parameter_name_value", - display_name="display_name_value", - description="description_value", - measurement_unit=resources.CustomMetric.MeasurementUnit.STANDARD, - scope=resources.CustomMetric.MetricScope.EVENT, - restricted_metric_type=[ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ], - ) + return_value = None # 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.CustomMetric.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"} - response = client.get_custom_metric(request) + response = client.archive_audience(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CustomMetric) - assert response.name == "name_value" - assert response.parameter_name == "parameter_name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.measurement_unit == resources.CustomMetric.MeasurementUnit.STANDARD - assert response.scope == resources.CustomMetric.MetricScope.EVENT - assert response.restricted_metric_type == [ - resources.CustomMetric.RestrictedMetricType.COST_DATA - ] + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_custom_metric_rest_interceptors(null_interceptor): +def test_archive_audience_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -103444,18 +109434,11 @@ def test_get_custom_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_custom_metric" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_custom_metric_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_custom_metric" + transports.AnalyticsAdminServiceRestInterceptor, "pre_archive_audience" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetCustomMetricRequest.pb( - analytics_admin.GetCustomMetricRequest() + pb_message = analytics_admin.ArchiveAudienceRequest.pb( + analytics_admin.ArchiveAudienceRequest() ) transcode.return_value = { "method": "post", @@ -103467,19 +109450,15 @@ def test_get_custom_metric_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.CustomMetric.to_json(resources.CustomMetric()) - req.return_value.content = return_value - request = analytics_admin.GetCustomMetricRequest() + request = analytics_admin.ArchiveAudienceRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CustomMetric() - post_with_metadata.return_value = resources.CustomMetric(), metadata - client.get_custom_metric( + client.archive_audience( request, metadata=[ ("key", "val"), @@ -103488,18 +109467,16 @@ def test_get_custom_metric_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_get_data_retention_settings_rest_bad_request( - request_type=analytics_admin.GetDataRetentionSettingsRequest, +def test_get_search_ads360_link_rest_bad_request( + request_type=analytics_admin.GetSearchAds360LinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataRetentionSettings"} + request_init = {"name": "properties/sample1/searchAds360Links/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -103514,33 +109491,32 @@ def test_get_data_retention_settings_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_data_retention_settings(request) + client.get_search_ads360_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetDataRetentionSettingsRequest, + analytics_admin.GetSearchAds360LinkRequest, dict, ], ) -def test_get_data_retention_settings_rest_call_success(request_type): +def test_get_search_ads360_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataRetentionSettings"} + request_init = {"name": "properties/sample1/searchAds360Links/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 = resources.DataRetentionSettings( + return_value = resources.SearchAds360Link( name="name_value", - event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - reset_user_data_on_new_activity=True, + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", ) # Wrap the value into a proper Response obj @@ -103548,29 +109524,22 @@ def test_get_data_retention_settings_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRetentionSettings.pb(return_value) + return_value = resources.SearchAds360Link.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_data_retention_settings(request) + response = client.get_search_ads360_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataRetentionSettings) + assert isinstance(response, resources.SearchAds360Link) assert response.name == "name_value" - assert ( - response.event_data_retention - == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS - ) - assert ( - response.user_data_retention - == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS - ) - assert response.reset_user_data_on_new_activity is True + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_data_retention_settings_rest_interceptors(null_interceptor): +def test_get_search_ads360_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -103584,20 +109553,18 @@ def test_get_data_retention_settings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_retention_settings", + transports.AnalyticsAdminServiceRestInterceptor, "post_get_search_ads360_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_retention_settings_with_metadata", + "post_get_search_ads360_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_data_retention_settings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_search_ads360_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetDataRetentionSettingsRequest.pb( - analytics_admin.GetDataRetentionSettingsRequest() + pb_message = analytics_admin.GetSearchAds360LinkRequest.pb( + analytics_admin.GetSearchAds360LinkRequest() ) transcode.return_value = { "method": "post", @@ -103609,21 +109576,19 @@ def test_get_data_retention_settings_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.DataRetentionSettings.to_json( - resources.DataRetentionSettings() - ) + return_value = resources.SearchAds360Link.to_json(resources.SearchAds360Link()) req.return_value.content = return_value - request = analytics_admin.GetDataRetentionSettingsRequest() + request = analytics_admin.GetSearchAds360LinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataRetentionSettings() - post_with_metadata.return_value = resources.DataRetentionSettings(), metadata + post.return_value = resources.SearchAds360Link() + post_with_metadata.return_value = resources.SearchAds360Link(), metadata - client.get_data_retention_settings( + client.get_search_ads360_link( request, metadata=[ ("key", "val"), @@ -103636,16 +109601,14 @@ def test_get_data_retention_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_data_retention_settings_rest_bad_request( - request_type=analytics_admin.UpdateDataRetentionSettingsRequest, +def test_list_search_ads360_links_rest_bad_request( + request_type=analytics_admin.ListSearchAds360LinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "data_retention_settings": {"name": "properties/sample1/dataRetentionSettings"} - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -103660,112 +109623,30 @@ def test_update_data_retention_settings_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_data_retention_settings(request) + client.list_search_ads360_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateDataRetentionSettingsRequest, + analytics_admin.ListSearchAds360LinksRequest, dict, ], ) -def test_update_data_retention_settings_rest_call_success(request_type): +def test_list_search_ads360_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "data_retention_settings": {"name": "properties/sample1/dataRetentionSettings"} - } - request_init["data_retention_settings"] = { - "name": "properties/sample1/dataRetentionSettings", - "event_data_retention": 1, - "user_data_retention": 1, - "reset_user_data_on_new_activity": True, - } - # 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 = analytics_admin.UpdateDataRetentionSettingsRequest.meta.fields[ - "data_retention_settings" - ] - - 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[ - "data_retention_settings" - ].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["data_retention_settings"][field])): - del request_init["data_retention_settings"][field][i][subfield] - else: - del request_init["data_retention_settings"][field][subfield] + request_init = {"parent": "properties/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.DataRetentionSettings( - name="name_value", - event_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - user_data_retention=resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS, - reset_user_data_on_new_activity=True, + return_value = analytics_admin.ListSearchAds360LinksResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -103773,29 +109654,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRetentionSettings.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_data_retention_settings(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataRetentionSettings) - assert response.name == "name_value" - assert ( - response.event_data_retention - == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS - ) - assert ( - response.user_data_retention - == resources.DataRetentionSettings.RetentionDuration.TWO_MONTHS - ) - assert response.reset_user_data_on_new_activity is True + return_value = analytics_admin.ListSearchAds360LinksResponse.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_search_ads360_links(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListSearchAds360LinksPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_data_retention_settings_rest_interceptors(null_interceptor): +def test_list_search_ads360_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -103809,20 +109681,18 @@ def test_update_data_retention_settings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_data_retention_settings", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_search_ads360_links" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_data_retention_settings_with_metadata", + "post_list_search_ads360_links_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_data_retention_settings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_search_ads360_links" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateDataRetentionSettingsRequest.pb( - analytics_admin.UpdateDataRetentionSettingsRequest() + pb_message = analytics_admin.ListSearchAds360LinksRequest.pb( + analytics_admin.ListSearchAds360LinksRequest() ) transcode.return_value = { "method": "post", @@ -103834,21 +109704,24 @@ def test_update_data_retention_settings_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.DataRetentionSettings.to_json( - resources.DataRetentionSettings() + return_value = analytics_admin.ListSearchAds360LinksResponse.to_json( + analytics_admin.ListSearchAds360LinksResponse() ) req.return_value.content = return_value - request = analytics_admin.UpdateDataRetentionSettingsRequest() + request = analytics_admin.ListSearchAds360LinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataRetentionSettings() - post_with_metadata.return_value = resources.DataRetentionSettings(), metadata + post.return_value = analytics_admin.ListSearchAds360LinksResponse() + post_with_metadata.return_value = ( + analytics_admin.ListSearchAds360LinksResponse(), + metadata, + ) - client.update_data_retention_settings( + client.list_search_ads360_links( request, metadata=[ ("key", "val"), @@ -103861,8 +109734,8 @@ def test_update_data_retention_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_data_stream_rest_bad_request( - request_type=analytics_admin.CreateDataStreamRequest, +def test_create_search_ads360_link_rest_bad_request( + request_type=analytics_admin.CreateSearchAds360LinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -103883,49 +109756,40 @@ def test_create_data_stream_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_data_stream(request) + client.create_search_ads360_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateDataStreamRequest, + analytics_admin.CreateSearchAds360LinkRequest, dict, ], ) -def test_create_data_stream_rest_call_success(request_type): +def test_create_search_ads360_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["data_stream"] = { - "web_stream_data": { - "measurement_id": "measurement_id_value", - "firebase_app_id": "firebase_app_id_value", - "default_uri": "default_uri_value", - }, - "android_app_stream_data": { - "firebase_app_id": "firebase_app_id_value", - "package_name": "package_name_value", - }, - "ios_app_stream_data": { - "firebase_app_id": "firebase_app_id_value", - "bundle_id": "bundle_id_value", - }, + request_init["search_ads_360_link"] = { "name": "name_value", - "type_": 1, - "display_name": "display_name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, + "advertiser_id": "advertiser_id_value", + "campaign_data_sharing_enabled": {"value": True}, + "cost_data_sharing_enabled": {}, + "advertiser_display_name": "advertiser_display_name_value", + "ads_personalization_enabled": {}, + "site_stats_sharing_enabled": {}, } # 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 = analytics_admin.CreateDataStreamRequest.meta.fields["data_stream"] + test_field = analytics_admin.CreateSearchAds360LinkRequest.meta.fields[ + "search_ads_360_link" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -103953,7 +109817,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["data_stream"].items(): # pragma: NO COVER + for field, value in request_init["search_ads_360_link"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -103983,19 +109847,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["data_stream"][field])): - del request_init["data_stream"][field][i][subfield] + for i in range(0, len(request_init["search_ads_360_link"][field])): + del request_init["search_ads_360_link"][field][i][subfield] else: - del request_init["data_stream"][field][subfield] + del request_init["search_ads_360_link"][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 = resources.DataStream( + return_value = resources.SearchAds360Link( name="name_value", - type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, - display_name="display_name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", ) # Wrap the value into a proper Response obj @@ -104003,22 +109867,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataStream.pb(return_value) + return_value = resources.SearchAds360Link.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.create_data_stream(request) + response = client.create_search_ads360_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataStream) + assert isinstance(response, resources.SearchAds360Link) assert response.name == "name_value" - assert response.type_ == resources.DataStream.DataStreamType.WEB_DATA_STREAM - assert response.display_name == "display_name_value" + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_data_stream_rest_interceptors(null_interceptor): +def test_create_search_ads360_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -104032,18 +109896,19 @@ def test_create_data_stream_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_data_stream" + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_search_ads360_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_data_stream_with_metadata", + "post_create_search_ads360_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_data_stream" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_search_ads360_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateDataStreamRequest.pb( - analytics_admin.CreateDataStreamRequest() + pb_message = analytics_admin.CreateSearchAds360LinkRequest.pb( + analytics_admin.CreateSearchAds360LinkRequest() ) transcode.return_value = { "method": "post", @@ -104055,19 +109920,19 @@ def test_create_data_stream_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.DataStream.to_json(resources.DataStream()) + return_value = resources.SearchAds360Link.to_json(resources.SearchAds360Link()) req.return_value.content = return_value - request = analytics_admin.CreateDataStreamRequest() + request = analytics_admin.CreateSearchAds360LinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataStream() - post_with_metadata.return_value = resources.DataStream(), metadata + post.return_value = resources.SearchAds360Link() + post_with_metadata.return_value = resources.SearchAds360Link(), metadata - client.create_data_stream( + client.create_search_ads360_link( request, metadata=[ ("key", "val"), @@ -104080,14 +109945,14 @@ def test_create_data_stream_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_data_stream_rest_bad_request( - request_type=analytics_admin.DeleteDataStreamRequest, +def test_delete_search_ads360_link_rest_bad_request( + request_type=analytics_admin.DeleteSearchAds360LinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/searchAds360Links/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -104102,23 +109967,23 @@ def test_delete_data_stream_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_data_stream(request) + client.delete_search_ads360_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteDataStreamRequest, + analytics_admin.DeleteSearchAds360LinkRequest, dict, ], ) -def test_delete_data_stream_rest_call_success(request_type): +def test_delete_search_ads360_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/searchAds360Links/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -104133,14 +109998,14 @@ def test_delete_data_stream_rest_call_success(request_type): 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_data_stream(request) + response = client.delete_search_ads360_link(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_data_stream_rest_interceptors(null_interceptor): +def test_delete_search_ads360_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -104154,11 +110019,11 @@ def test_delete_data_stream_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_data_stream" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_search_ads360_link" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteDataStreamRequest.pb( - analytics_admin.DeleteDataStreamRequest() + pb_message = analytics_admin.DeleteSearchAds360LinkRequest.pb( + analytics_admin.DeleteSearchAds360LinkRequest() ) transcode.return_value = { "method": "post", @@ -104171,14 +110036,14 @@ def test_delete_data_stream_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.DeleteDataStreamRequest() + request = analytics_admin.DeleteSearchAds360LinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_data_stream( + client.delete_search_ads360_link( request, metadata=[ ("key", "val"), @@ -104189,14 +110054,16 @@ def test_delete_data_stream_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_update_data_stream_rest_bad_request( - request_type=analytics_admin.UpdateDataStreamRequest, +def test_update_search_ads360_link_rest_bad_request( + request_type=analytics_admin.UpdateSearchAds360LinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"data_stream": {"name": "properties/sample1/dataStreams/sample2"}} + request_init = { + "search_ads_360_link": {"name": "properties/sample1/searchAds360Links/sample2"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -104211,49 +110078,42 @@ def test_update_data_stream_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_data_stream(request) + client.update_search_ads360_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateDataStreamRequest, + analytics_admin.UpdateSearchAds360LinkRequest, dict, ], ) -def test_update_data_stream_rest_call_success(request_type): +def test_update_search_ads360_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"data_stream": {"name": "properties/sample1/dataStreams/sample2"}} - request_init["data_stream"] = { - "web_stream_data": { - "measurement_id": "measurement_id_value", - "firebase_app_id": "firebase_app_id_value", - "default_uri": "default_uri_value", - }, - "android_app_stream_data": { - "firebase_app_id": "firebase_app_id_value", - "package_name": "package_name_value", - }, - "ios_app_stream_data": { - "firebase_app_id": "firebase_app_id_value", - "bundle_id": "bundle_id_value", - }, - "name": "properties/sample1/dataStreams/sample2", - "type_": 1, - "display_name": "display_name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, + request_init = { + "search_ads_360_link": {"name": "properties/sample1/searchAds360Links/sample2"} + } + request_init["search_ads_360_link"] = { + "name": "properties/sample1/searchAds360Links/sample2", + "advertiser_id": "advertiser_id_value", + "campaign_data_sharing_enabled": {"value": True}, + "cost_data_sharing_enabled": {}, + "advertiser_display_name": "advertiser_display_name_value", + "ads_personalization_enabled": {}, + "site_stats_sharing_enabled": {}, } # 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 = analytics_admin.UpdateDataStreamRequest.meta.fields["data_stream"] + test_field = analytics_admin.UpdateSearchAds360LinkRequest.meta.fields[ + "search_ads_360_link" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -104281,7 +110141,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["data_stream"].items(): # pragma: NO COVER + for field, value in request_init["search_ads_360_link"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -104311,19 +110171,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["data_stream"][field])): - del request_init["data_stream"][field][i][subfield] + for i in range(0, len(request_init["search_ads_360_link"][field])): + del request_init["search_ads_360_link"][field][i][subfield] else: - del request_init["data_stream"][field][subfield] + del request_init["search_ads_360_link"][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 = resources.DataStream( + return_value = resources.SearchAds360Link( name="name_value", - type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, - display_name="display_name_value", + advertiser_id="advertiser_id_value", + advertiser_display_name="advertiser_display_name_value", ) # Wrap the value into a proper Response obj @@ -104331,22 +110191,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataStream.pb(return_value) + return_value = resources.SearchAds360Link.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_data_stream(request) + response = client.update_search_ads360_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataStream) + assert isinstance(response, resources.SearchAds360Link) assert response.name == "name_value" - assert response.type_ == resources.DataStream.DataStreamType.WEB_DATA_STREAM - assert response.display_name == "display_name_value" + assert response.advertiser_id == "advertiser_id_value" + assert response.advertiser_display_name == "advertiser_display_name_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_data_stream_rest_interceptors(null_interceptor): +def test_update_search_ads360_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -104360,18 +110220,19 @@ def test_update_data_stream_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_data_stream" + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_search_ads360_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_data_stream_with_metadata", + "post_update_search_ads360_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_data_stream" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_search_ads360_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateDataStreamRequest.pb( - analytics_admin.UpdateDataStreamRequest() + pb_message = analytics_admin.UpdateSearchAds360LinkRequest.pb( + analytics_admin.UpdateSearchAds360LinkRequest() ) transcode.return_value = { "method": "post", @@ -104383,19 +110244,19 @@ def test_update_data_stream_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.DataStream.to_json(resources.DataStream()) + return_value = resources.SearchAds360Link.to_json(resources.SearchAds360Link()) req.return_value.content = return_value - request = analytics_admin.UpdateDataStreamRequest() + request = analytics_admin.UpdateSearchAds360LinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataStream() - post_with_metadata.return_value = resources.DataStream(), metadata + post.return_value = resources.SearchAds360Link() + post_with_metadata.return_value = resources.SearchAds360Link(), metadata - client.update_data_stream( + client.update_search_ads360_link( request, metadata=[ ("key", "val"), @@ -104408,14 +110269,14 @@ def test_update_data_stream_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_data_streams_rest_bad_request( - request_type=analytics_admin.ListDataStreamsRequest, +def test_get_attribution_settings_rest_bad_request( + request_type=analytics_admin.GetAttributionSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"name": "properties/sample1/attributionSettings"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -104430,30 +110291,34 @@ def test_list_data_streams_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.list_data_streams(request) + client.get_attribution_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListDataStreamsRequest, + analytics_admin.GetAttributionSettingsRequest, dict, ], ) -def test_list_data_streams_rest_call_success(request_type): +def test_get_attribution_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"name": "properties/sample1/attributionSettings"} 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 = analytics_admin.ListDataStreamsResponse( - next_page_token="next_page_token_value", + return_value = resources.AttributionSettings( + name="name_value", + acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, + other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, + reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, + ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, ) # Wrap the value into a proper Response obj @@ -104461,20 +110326,36 @@ def test_list_data_streams_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListDataStreamsResponse.pb(return_value) + return_value = resources.AttributionSettings.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_data_streams(request) + response = client.get_attribution_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListDataStreamsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.AttributionSettings) + assert response.name == "name_value" + assert ( + response.acquisition_conversion_event_lookback_window + == resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS + ) + assert ( + response.other_conversion_event_lookback_window + == resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS + ) + assert ( + response.reporting_attribution_model + == resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN + ) + assert ( + response.ads_web_conversion_data_export_scope + == resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_data_streams_rest_interceptors(null_interceptor): +def test_get_attribution_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -104488,18 +110369,18 @@ def test_list_data_streams_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_data_streams" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_attribution_settings" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_data_streams_with_metadata", + "post_get_attribution_settings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_data_streams" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_attribution_settings" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListDataStreamsRequest.pb( - analytics_admin.ListDataStreamsRequest() + pb_message = analytics_admin.GetAttributionSettingsRequest.pb( + analytics_admin.GetAttributionSettingsRequest() ) transcode.return_value = { "method": "post", @@ -104511,24 +110392,21 @@ def test_list_data_streams_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 = analytics_admin.ListDataStreamsResponse.to_json( - analytics_admin.ListDataStreamsResponse() + return_value = resources.AttributionSettings.to_json( + resources.AttributionSettings() ) req.return_value.content = return_value - request = analytics_admin.ListDataStreamsRequest() + request = analytics_admin.GetAttributionSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListDataStreamsResponse() - post_with_metadata.return_value = ( - analytics_admin.ListDataStreamsResponse(), - metadata, - ) + post.return_value = resources.AttributionSettings() + post_with_metadata.return_value = resources.AttributionSettings(), metadata - client.list_data_streams( + client.get_attribution_settings( request, metadata=[ ("key", "val"), @@ -104541,14 +110419,16 @@ def test_list_data_streams_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_data_stream_rest_bad_request( - request_type=analytics_admin.GetDataStreamRequest, +def test_update_attribution_settings_rest_bad_request( + request_type=analytics_admin.UpdateAttributionSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataStreams/sample2"} + request_init = { + "attribution_settings": {"name": "properties/sample1/attributionSettings"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -104563,165 +110443,114 @@ def test_get_data_stream_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_data_stream(request) + client.update_attribution_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetDataStreamRequest, + analytics_admin.UpdateAttributionSettingsRequest, dict, ], ) -def test_get_data_stream_rest_call_success(request_type): +def test_update_attribution_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/dataStreams/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 = resources.DataStream( - name="name_value", - type_=resources.DataStream.DataStreamType.WEB_DATA_STREAM, - 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.DataStream.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_data_stream(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataStream) - assert response.name == "name_value" - assert response.type_ == resources.DataStream.DataStreamType.WEB_DATA_STREAM - assert response.display_name == "display_name_value" - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_data_stream_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_get_data_stream" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_stream_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_data_stream" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetDataStreamRequest.pb( - analytics_admin.GetDataStreamRequest() - ) - 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.DataStream.to_json(resources.DataStream()) - req.return_value.content = return_value + request_init = { + "attribution_settings": {"name": "properties/sample1/attributionSettings"} + } + request_init["attribution_settings"] = { + "name": "properties/sample1/attributionSettings", + "acquisition_conversion_event_lookback_window": 1, + "other_conversion_event_lookback_window": 1, + "reporting_attribution_model": 1, + "ads_web_conversion_data_export_scope": 1, + } + # 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 - request = analytics_admin.GetDataStreamRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = resources.DataStream() - post_with_metadata.return_value = resources.DataStream(), metadata + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateAttributionSettingsRequest.meta.fields[ + "attribution_settings" + ] - client.get_data_stream( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) + 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 = [] - pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() + 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 -def test_get_audience_rest_bad_request(request_type=analytics_admin.GetAudienceRequest): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/audiences/sample2"} - request = request_type(**request_init) + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] - # 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_audience(request) + 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[ + "attribution_settings" + ].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 -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.GetAudienceRequest, - dict, - ], -) -def test_get_audience_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + 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, + } + ) - # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/audiences/sample2"} + # 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["attribution_settings"][field])): + del request_init["attribution_settings"][field][i][subfield] + else: + del request_init["attribution_settings"][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 = audience.Audience( + return_value = resources.AttributionSettings( name="name_value", - display_name="display_name_value", - description="description_value", - membership_duration_days=2561, - ads_personalization_enabled=True, - exclusion_duration_mode=audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, + other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, + reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, + ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, ) # Wrap the value into a proper Response obj @@ -104729,28 +110558,36 @@ def test_get_audience_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = audience.Audience.pb(return_value) + return_value = resources.AttributionSettings.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_audience(request) + response = client.update_attribution_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, audience.Audience) + assert isinstance(response, resources.AttributionSettings) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.membership_duration_days == 2561 - assert response.ads_personalization_enabled is True assert ( - response.exclusion_duration_mode - == audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY + response.acquisition_conversion_event_lookback_window + == resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS + ) + assert ( + response.other_conversion_event_lookback_window + == resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS + ) + assert ( + response.reporting_attribution_model + == resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN + ) + assert ( + response.ads_web_conversion_data_export_scope + == resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_audience_rest_interceptors(null_interceptor): +def test_update_attribution_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -104764,18 +110601,20 @@ def test_get_audience_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_audience" + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_attribution_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_audience_with_metadata", + "post_update_attribution_settings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_audience" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_update_attribution_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetAudienceRequest.pb( - analytics_admin.GetAudienceRequest() + pb_message = analytics_admin.UpdateAttributionSettingsRequest.pb( + analytics_admin.UpdateAttributionSettingsRequest() ) transcode.return_value = { "method": "post", @@ -104787,19 +110626,21 @@ def test_get_audience_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 = audience.Audience.to_json(audience.Audience()) + return_value = resources.AttributionSettings.to_json( + resources.AttributionSettings() + ) req.return_value.content = return_value - request = analytics_admin.GetAudienceRequest() + request = analytics_admin.UpdateAttributionSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = audience.Audience() - post_with_metadata.return_value = audience.Audience(), metadata + post.return_value = resources.AttributionSettings() + post_with_metadata.return_value = resources.AttributionSettings(), metadata - client.get_audience( + client.update_attribution_settings( request, metadata=[ ("key", "val"), @@ -104812,14 +110653,14 @@ def test_get_audience_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_audiences_rest_bad_request( - request_type=analytics_admin.ListAudiencesRequest, +def test_run_access_report_rest_bad_request( + request_type=analytics_admin.RunAccessReportRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"entity": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -104834,30 +110675,30 @@ def test_list_audiences_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.list_audiences(request) + client.run_access_report(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListAudiencesRequest, + analytics_admin.RunAccessReportRequest, dict, ], ) -def test_list_audiences_rest_call_success(request_type): +def test_run_access_report_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"entity": "properties/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 = analytics_admin.ListAudiencesResponse( - next_page_token="next_page_token_value", + return_value = analytics_admin.RunAccessReportResponse( + row_count=992, ) # Wrap the value into a proper Response obj @@ -104865,20 +110706,20 @@ def test_list_audiences_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAudiencesResponse.pb(return_value) + return_value = analytics_admin.RunAccessReportResponse.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_audiences(request) + response = client.run_access_report(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAudiencesPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, analytics_admin.RunAccessReportResponse) + assert response.row_count == 992 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_audiences_rest_interceptors(null_interceptor): +def test_run_access_report_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -104892,18 +110733,18 @@ def test_list_audiences_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_audiences" + transports.AnalyticsAdminServiceRestInterceptor, "post_run_access_report" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_audiences_with_metadata", + "post_run_access_report_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_audiences" + transports.AnalyticsAdminServiceRestInterceptor, "pre_run_access_report" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListAudiencesRequest.pb( - analytics_admin.ListAudiencesRequest() + pb_message = analytics_admin.RunAccessReportRequest.pb( + analytics_admin.RunAccessReportRequest() ) transcode.return_value = { "method": "post", @@ -104915,24 +110756,24 @@ def test_list_audiences_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 = analytics_admin.ListAudiencesResponse.to_json( - analytics_admin.ListAudiencesResponse() + return_value = analytics_admin.RunAccessReportResponse.to_json( + analytics_admin.RunAccessReportResponse() ) req.return_value.content = return_value - request = analytics_admin.ListAudiencesRequest() + request = analytics_admin.RunAccessReportRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListAudiencesResponse() + post.return_value = analytics_admin.RunAccessReportResponse() post_with_metadata.return_value = ( - analytics_admin.ListAudiencesResponse(), + analytics_admin.RunAccessReportResponse(), metadata, ) - client.list_audiences( + client.run_access_report( request, metadata=[ ("key", "val"), @@ -104945,14 +110786,14 @@ def test_list_audiences_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_audience_rest_bad_request( - request_type=analytics_admin.CreateAudienceRequest, +def test_create_access_binding_rest_bad_request( + request_type=analytics_admin.CreateAccessBindingRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -104967,90 +110808,36 @@ def test_create_audience_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_audience(request) + client.create_access_binding(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateAudienceRequest, + analytics_admin.CreateAccessBindingRequest, dict, ], ) -def test_create_audience_rest_call_success(request_type): +def test_create_access_binding_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["audience"] = { + request_init = {"parent": "accounts/sample1"} + request_init["access_binding"] = { + "user": "user_value", "name": "name_value", - "display_name": "display_name_value", - "description": "description_value", - "membership_duration_days": 2561, - "ads_personalization_enabled": True, - "event_trigger": {"event_name": "event_name_value", "log_condition": 1}, - "exclusion_duration_mode": 1, - "filter_clauses": [ - { - "simple_filter": { - "scope": 1, - "filter_expression": { - "and_group": {"filter_expressions": {}}, - "or_group": {}, - "not_expression": {}, - "dimension_or_metric_filter": { - "string_filter": { - "match_type": 1, - "value": "value_value", - "case_sensitive": True, - }, - "in_list_filter": { - "values": ["values_value1", "values_value2"], - "case_sensitive": True, - }, - "numeric_filter": { - "operation": 1, - "value": { - "int64_value": 1073, - "double_value": 0.12710000000000002, - }, - }, - "between_filter": {"from_value": {}, "to_value": {}}, - "field_name": "field_name_value", - "at_any_point_in_time": True, - "in_any_n_day_period": 1994, - }, - "event_filter": { - "event_name": "event_name_value", - "event_parameter_filter_expression": {}, - }, - }, - }, - "sequence_filter": { - "scope": 1, - "sequence_maximum_duration": {"seconds": 751, "nanos": 543}, - "sequence_steps": [ - { - "scope": 1, - "immediately_follows": True, - "constraint_duration": {}, - "filter_expression": {}, - } - ], - }, - "clause_type": 1, - } - ], - "create_time": {"seconds": 751, "nanos": 543}, + "roles": ["roles_value1", "roles_value2"], } # 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 = analytics_admin.CreateAudienceRequest.meta.fields["audience"] + test_field = analytics_admin.CreateAccessBindingRequest.meta.fields[ + "access_binding" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -105078,7 +110865,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["audience"].items(): # pragma: NO COVER + for field, value in request_init["access_binding"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -105108,22 +110895,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["audience"][field])): - del request_init["audience"][field][i][subfield] + for i in range(0, len(request_init["access_binding"][field])): + del request_init["access_binding"][field][i][subfield] else: - del request_init["audience"][field][subfield] + del request_init["access_binding"][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 = gaa_audience.Audience( + return_value = resources.AccessBinding( name="name_value", - display_name="display_name_value", - description="description_value", - membership_duration_days=2561, - ads_personalization_enabled=True, - exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + roles=["roles_value"], + user="user_value", ) # Wrap the value into a proper Response obj @@ -105131,28 +110915,152 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_audience.Audience.pb(return_value) + return_value = resources.AccessBinding.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.create_audience(request) + response = client.create_access_binding(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_audience.Audience) + assert isinstance(response, resources.AccessBinding) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.membership_duration_days == 2561 - assert response.ads_personalization_enabled is True - assert ( - response.exclusion_duration_mode - == gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY + assert response.roles == ["roles_value"] + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_access_binding_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_create_access_binding" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_access_binding_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_access_binding" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.CreateAccessBindingRequest.pb( + analytics_admin.CreateAccessBindingRequest() + ) + 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.AccessBinding.to_json(resources.AccessBinding()) + req.return_value.content = return_value + + request = analytics_admin.CreateAccessBindingRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = resources.AccessBinding() + post_with_metadata.return_value = resources.AccessBinding(), metadata + + client.create_access_binding( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_access_binding_rest_bad_request( + request_type=analytics_admin.GetAccessBindingRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "accounts/sample1/accessBindings/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.get_access_binding(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.GetAccessBindingRequest, + dict, + ], +) +def test_get_access_binding_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) + # send a request that will satisfy transcoding + request_init = {"name": "accounts/sample1/accessBindings/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 = resources.AccessBinding( + name="name_value", + roles=["roles_value"], + user="user_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.AccessBinding.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_access_binding(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.AccessBinding) + assert response.name == "name_value" + assert response.roles == ["roles_value"] + @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_audience_rest_interceptors(null_interceptor): +def test_get_access_binding_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -105166,18 +111074,18 @@ def test_create_audience_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_audience" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_access_binding" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_audience_with_metadata", + "post_get_access_binding_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_audience" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_access_binding" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateAudienceRequest.pb( - analytics_admin.CreateAudienceRequest() + pb_message = analytics_admin.GetAccessBindingRequest.pb( + analytics_admin.GetAccessBindingRequest() ) transcode.return_value = { "method": "post", @@ -105189,19 +111097,19 @@ def test_create_audience_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 = gaa_audience.Audience.to_json(gaa_audience.Audience()) + return_value = resources.AccessBinding.to_json(resources.AccessBinding()) req.return_value.content = return_value - request = analytics_admin.CreateAudienceRequest() + request = analytics_admin.GetAccessBindingRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_audience.Audience() - post_with_metadata.return_value = gaa_audience.Audience(), metadata + post.return_value = resources.AccessBinding() + post_with_metadata.return_value = resources.AccessBinding(), metadata - client.create_audience( + client.get_access_binding( request, metadata=[ ("key", "val"), @@ -105214,14 +111122,16 @@ def test_create_audience_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_audience_rest_bad_request( - request_type=analytics_admin.UpdateAudienceRequest, +def test_update_access_binding_rest_bad_request( + request_type=analytics_admin.UpdateAccessBindingRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"audience": {"name": "properties/sample1/audiences/sample2"}} + request_init = { + "access_binding": {"name": "accounts/sample1/accessBindings/sample2"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -105236,90 +111146,38 @@ def test_update_audience_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_audience(request) + client.update_access_binding(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateAudienceRequest, + analytics_admin.UpdateAccessBindingRequest, dict, ], ) -def test_update_audience_rest_call_success(request_type): +def test_update_access_binding_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"audience": {"name": "properties/sample1/audiences/sample2"}} - request_init["audience"] = { - "name": "properties/sample1/audiences/sample2", - "display_name": "display_name_value", - "description": "description_value", - "membership_duration_days": 2561, - "ads_personalization_enabled": True, - "event_trigger": {"event_name": "event_name_value", "log_condition": 1}, - "exclusion_duration_mode": 1, - "filter_clauses": [ - { - "simple_filter": { - "scope": 1, - "filter_expression": { - "and_group": {"filter_expressions": {}}, - "or_group": {}, - "not_expression": {}, - "dimension_or_metric_filter": { - "string_filter": { - "match_type": 1, - "value": "value_value", - "case_sensitive": True, - }, - "in_list_filter": { - "values": ["values_value1", "values_value2"], - "case_sensitive": True, - }, - "numeric_filter": { - "operation": 1, - "value": { - "int64_value": 1073, - "double_value": 0.12710000000000002, - }, - }, - "between_filter": {"from_value": {}, "to_value": {}}, - "field_name": "field_name_value", - "at_any_point_in_time": True, - "in_any_n_day_period": 1994, - }, - "event_filter": { - "event_name": "event_name_value", - "event_parameter_filter_expression": {}, - }, - }, - }, - "sequence_filter": { - "scope": 1, - "sequence_maximum_duration": {"seconds": 751, "nanos": 543}, - "sequence_steps": [ - { - "scope": 1, - "immediately_follows": True, - "constraint_duration": {}, - "filter_expression": {}, - } - ], - }, - "clause_type": 1, - } - ], - "create_time": {"seconds": 751, "nanos": 543}, + request_init = { + "access_binding": {"name": "accounts/sample1/accessBindings/sample2"} + } + request_init["access_binding"] = { + "user": "user_value", + "name": "accounts/sample1/accessBindings/sample2", + "roles": ["roles_value1", "roles_value2"], } # 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 = analytics_admin.UpdateAudienceRequest.meta.fields["audience"] + test_field = analytics_admin.UpdateAccessBindingRequest.meta.fields[ + "access_binding" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -105347,7 +111205,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["audience"].items(): # pragma: NO COVER + for field, value in request_init["access_binding"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -105377,22 +111235,19 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["audience"][field])): - del request_init["audience"][field][i][subfield] + for i in range(0, len(request_init["access_binding"][field])): + del request_init["access_binding"][field][i][subfield] else: - del request_init["audience"][field][subfield] + del request_init["access_binding"][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 = gaa_audience.Audience( + return_value = resources.AccessBinding( name="name_value", - display_name="display_name_value", - description="description_value", - membership_duration_days=2561, - ads_personalization_enabled=True, - exclusion_duration_mode=gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY, + roles=["roles_value"], + user="user_value", ) # Wrap the value into a proper Response obj @@ -105400,28 +111255,21 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_audience.Audience.pb(return_value) + return_value = resources.AccessBinding.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_audience(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, gaa_audience.Audience) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.membership_duration_days == 2561 - assert response.ads_personalization_enabled is True - assert ( - response.exclusion_duration_mode - == gaa_audience.Audience.AudienceExclusionDurationMode.EXCLUDE_TEMPORARILY - ) + response = client.update_access_binding(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, resources.AccessBinding) + assert response.name == "name_value" + assert response.roles == ["roles_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_audience_rest_interceptors(null_interceptor): +def test_update_access_binding_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -105435,18 +111283,18 @@ def test_update_audience_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_audience" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_access_binding" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_audience_with_metadata", + "post_update_access_binding_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_audience" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_access_binding" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateAudienceRequest.pb( - analytics_admin.UpdateAudienceRequest() + pb_message = analytics_admin.UpdateAccessBindingRequest.pb( + analytics_admin.UpdateAccessBindingRequest() ) transcode.return_value = { "method": "post", @@ -105458,19 +111306,19 @@ def test_update_audience_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 = gaa_audience.Audience.to_json(gaa_audience.Audience()) + return_value = resources.AccessBinding.to_json(resources.AccessBinding()) req.return_value.content = return_value - request = analytics_admin.UpdateAudienceRequest() + request = analytics_admin.UpdateAccessBindingRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_audience.Audience() - post_with_metadata.return_value = gaa_audience.Audience(), metadata + post.return_value = resources.AccessBinding() + post_with_metadata.return_value = resources.AccessBinding(), metadata - client.update_audience( + client.update_access_binding( request, metadata=[ ("key", "val"), @@ -105483,14 +111331,14 @@ def test_update_audience_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_archive_audience_rest_bad_request( - request_type=analytics_admin.ArchiveAudienceRequest, +def test_delete_access_binding_rest_bad_request( + request_type=analytics_admin.DeleteAccessBindingRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/audiences/sample2"} + request_init = {"name": "accounts/sample1/accessBindings/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -105505,23 +111353,23 @@ def test_archive_audience_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.archive_audience(request) + client.delete_access_binding(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ArchiveAudienceRequest, + analytics_admin.DeleteAccessBindingRequest, dict, ], ) -def test_archive_audience_rest_call_success(request_type): +def test_delete_access_binding_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/audiences/sample2"} + request_init = {"name": "accounts/sample1/accessBindings/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -105536,14 +111384,14 @@ def test_archive_audience_rest_call_success(request_type): 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.archive_audience(request) + response = client.delete_access_binding(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_archive_audience_rest_interceptors(null_interceptor): +def test_delete_access_binding_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -105557,11 +111405,11 @@ def test_archive_audience_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_archive_audience" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_access_binding" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.ArchiveAudienceRequest.pb( - analytics_admin.ArchiveAudienceRequest() + pb_message = analytics_admin.DeleteAccessBindingRequest.pb( + analytics_admin.DeleteAccessBindingRequest() ) transcode.return_value = { "method": "post", @@ -105574,14 +111422,14 @@ def test_archive_audience_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.ArchiveAudienceRequest() + request = analytics_admin.DeleteAccessBindingRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.archive_audience( + client.delete_access_binding( request, metadata=[ ("key", "val"), @@ -105592,14 +111440,14 @@ def test_archive_audience_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_get_search_ads360_link_rest_bad_request( - request_type=analytics_admin.GetSearchAds360LinkRequest, +def test_list_access_bindings_rest_bad_request( + request_type=analytics_admin.ListAccessBindingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/searchAds360Links/sample2"} + request_init = {"parent": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -105614,32 +111462,30 @@ def test_get_search_ads360_link_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_search_ads360_link(request) + client.list_access_bindings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetSearchAds360LinkRequest, + analytics_admin.ListAccessBindingsRequest, dict, ], ) -def test_get_search_ads360_link_rest_call_success(request_type): +def test_list_access_bindings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/searchAds360Links/sample2"} + request_init = {"parent": "accounts/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.SearchAds360Link( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", + return_value = analytics_admin.ListAccessBindingsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -105647,22 +111493,20 @@ def test_get_search_ads360_link_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.SearchAds360Link.pb(return_value) + return_value = analytics_admin.ListAccessBindingsResponse.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_search_ads360_link(request) + response = client.list_access_bindings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.SearchAds360Link) - assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" + assert isinstance(response, pagers.ListAccessBindingsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_search_ads360_link_rest_interceptors(null_interceptor): +def test_list_access_bindings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -105676,18 +111520,18 @@ def test_get_search_ads360_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_search_ads360_link" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_access_bindings" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_search_ads360_link_with_metadata", + "post_list_access_bindings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_search_ads360_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_access_bindings" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetSearchAds360LinkRequest.pb( - analytics_admin.GetSearchAds360LinkRequest() + pb_message = analytics_admin.ListAccessBindingsRequest.pb( + analytics_admin.ListAccessBindingsRequest() ) transcode.return_value = { "method": "post", @@ -105699,19 +111543,24 @@ def test_get_search_ads360_link_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.SearchAds360Link.to_json(resources.SearchAds360Link()) + return_value = analytics_admin.ListAccessBindingsResponse.to_json( + analytics_admin.ListAccessBindingsResponse() + ) req.return_value.content = return_value - request = analytics_admin.GetSearchAds360LinkRequest() + request = analytics_admin.ListAccessBindingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.SearchAds360Link() - post_with_metadata.return_value = resources.SearchAds360Link(), metadata + post.return_value = analytics_admin.ListAccessBindingsResponse() + post_with_metadata.return_value = ( + analytics_admin.ListAccessBindingsResponse(), + metadata, + ) - client.get_search_ads360_link( + client.list_access_bindings( request, metadata=[ ("key", "val"), @@ -105724,14 +111573,14 @@ def test_get_search_ads360_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_search_ads360_links_rest_bad_request( - request_type=analytics_admin.ListSearchAds360LinksRequest, +def test_batch_create_access_bindings_rest_bad_request( + request_type=analytics_admin.BatchCreateAccessBindingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -105746,51 +111595,50 @@ def test_list_search_ads360_links_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.list_search_ads360_links(request) + client.batch_create_access_bindings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListSearchAds360LinksRequest, + analytics_admin.BatchCreateAccessBindingsRequest, dict, ], ) -def test_list_search_ads360_links_rest_call_success(request_type): +def test_batch_create_access_bindings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "accounts/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 = analytics_admin.ListSearchAds360LinksResponse( - next_page_token="next_page_token_value", - ) + return_value = analytics_admin.BatchCreateAccessBindingsResponse() # 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 = analytics_admin.ListSearchAds360LinksResponse.pb(return_value) + return_value = analytics_admin.BatchCreateAccessBindingsResponse.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_search_ads360_links(request) + response = client.batch_create_access_bindings(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListSearchAds360LinksPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, analytics_admin.BatchCreateAccessBindingsResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_search_ads360_links_rest_interceptors(null_interceptor): +def test_batch_create_access_bindings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -105804,18 +111652,20 @@ def test_list_search_ads360_links_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_search_ads360_links" + transports.AnalyticsAdminServiceRestInterceptor, + "post_batch_create_access_bindings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_search_ads360_links_with_metadata", + "post_batch_create_access_bindings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_search_ads360_links" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_batch_create_access_bindings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListSearchAds360LinksRequest.pb( - analytics_admin.ListSearchAds360LinksRequest() + pb_message = analytics_admin.BatchCreateAccessBindingsRequest.pb( + analytics_admin.BatchCreateAccessBindingsRequest() ) transcode.return_value = { "method": "post", @@ -105827,24 +111677,24 @@ def test_list_search_ads360_links_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 = analytics_admin.ListSearchAds360LinksResponse.to_json( - analytics_admin.ListSearchAds360LinksResponse() + return_value = analytics_admin.BatchCreateAccessBindingsResponse.to_json( + analytics_admin.BatchCreateAccessBindingsResponse() ) req.return_value.content = return_value - request = analytics_admin.ListSearchAds360LinksRequest() + request = analytics_admin.BatchCreateAccessBindingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListSearchAds360LinksResponse() + post.return_value = analytics_admin.BatchCreateAccessBindingsResponse() post_with_metadata.return_value = ( - analytics_admin.ListSearchAds360LinksResponse(), + analytics_admin.BatchCreateAccessBindingsResponse(), metadata, ) - client.list_search_ads360_links( + client.batch_create_access_bindings( request, metadata=[ ("key", "val"), @@ -105857,14 +111707,14 @@ def test_list_search_ads360_links_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_search_ads360_link_rest_bad_request( - request_type=analytics_admin.CreateSearchAds360LinkRequest, +def test_batch_get_access_bindings_rest_bad_request( + request_type=analytics_admin.BatchGetAccessBindingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -105879,133 +111729,48 @@ def test_create_search_ads360_link_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_search_ads360_link(request) + client.batch_get_access_bindings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateSearchAds360LinkRequest, + analytics_admin.BatchGetAccessBindingsRequest, dict, ], ) -def test_create_search_ads360_link_rest_call_success(request_type): +def test_batch_get_access_bindings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["search_ads_360_link"] = { - "name": "name_value", - "advertiser_id": "advertiser_id_value", - "campaign_data_sharing_enabled": {"value": True}, - "cost_data_sharing_enabled": {}, - "advertiser_display_name": "advertiser_display_name_value", - "ads_personalization_enabled": {}, - "site_stats_sharing_enabled": {}, - } - # 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 = analytics_admin.CreateSearchAds360LinkRequest.meta.fields[ - "search_ads_360_link" - ] - - 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["search_ads_360_link"].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["search_ads_360_link"][field])): - del request_init["search_ads_360_link"][field][i][subfield] - else: - del request_init["search_ads_360_link"][field][subfield] + request_init = {"parent": "accounts/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.SearchAds360Link( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) + return_value = analytics_admin.BatchGetAccessBindingsResponse() # 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.SearchAds360Link.pb(return_value) + return_value = analytics_admin.BatchGetAccessBindingsResponse.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.create_search_ads360_link(request) + response = client.batch_get_access_bindings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.SearchAds360Link) - assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" + assert isinstance(response, analytics_admin.BatchGetAccessBindingsResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_search_ads360_link_rest_interceptors(null_interceptor): +def test_batch_get_access_bindings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -106020,18 +111785,18 @@ def test_create_search_ads360_link_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_search_ads360_link", + "post_batch_get_access_bindings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_search_ads360_link_with_metadata", + "post_batch_get_access_bindings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_search_ads360_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_batch_get_access_bindings" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateSearchAds360LinkRequest.pb( - analytics_admin.CreateSearchAds360LinkRequest() + pb_message = analytics_admin.BatchGetAccessBindingsRequest.pb( + analytics_admin.BatchGetAccessBindingsRequest() ) transcode.return_value = { "method": "post", @@ -106043,19 +111808,24 @@ def test_create_search_ads360_link_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.SearchAds360Link.to_json(resources.SearchAds360Link()) + return_value = analytics_admin.BatchGetAccessBindingsResponse.to_json( + analytics_admin.BatchGetAccessBindingsResponse() + ) req.return_value.content = return_value - request = analytics_admin.CreateSearchAds360LinkRequest() + request = analytics_admin.BatchGetAccessBindingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.SearchAds360Link() - post_with_metadata.return_value = resources.SearchAds360Link(), metadata + post.return_value = analytics_admin.BatchGetAccessBindingsResponse() + post_with_metadata.return_value = ( + analytics_admin.BatchGetAccessBindingsResponse(), + metadata, + ) - client.create_search_ads360_link( + client.batch_get_access_bindings( request, metadata=[ ("key", "val"), @@ -106068,125 +111838,14 @@ def test_create_search_ads360_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_search_ads360_link_rest_bad_request( - request_type=analytics_admin.DeleteSearchAds360LinkRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/searchAds360Links/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.delete_search_ads360_link(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.DeleteSearchAds360LinkRequest, - dict, - ], -) -def test_delete_search_ads360_link_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/searchAds360Links/sample2"} - request = request_type(**request_init) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # Wrap the value into a proper Response obj - response_value = 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_search_ads360_link(request) - - # Establish that the response is the type that we expect. - assert response is None - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_search_ads360_link_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "pre_delete_search_ads360_link" - ) as pre: - pre.assert_not_called() - pb_message = analytics_admin.DeleteSearchAds360LinkRequest.pb( - analytics_admin.DeleteSearchAds360LinkRequest() - ) - 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"} - - request = analytics_admin.DeleteSearchAds360LinkRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - - client.delete_search_ads360_link( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - - -def test_update_search_ads360_link_rest_bad_request( - request_type=analytics_admin.UpdateSearchAds360LinkRequest, +def test_batch_update_access_bindings_rest_bad_request( + request_type=analytics_admin.BatchUpdateAccessBindingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "search_ads_360_link": {"name": "properties/sample1/searchAds360Links/sample2"} - } + request_init = {"parent": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -106201,135 +111860,50 @@ def test_update_search_ads360_link_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_search_ads360_link(request) + client.batch_update_access_bindings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateSearchAds360LinkRequest, + analytics_admin.BatchUpdateAccessBindingsRequest, dict, ], ) -def test_update_search_ads360_link_rest_call_success(request_type): +def test_batch_update_access_bindings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "search_ads_360_link": {"name": "properties/sample1/searchAds360Links/sample2"} - } - request_init["search_ads_360_link"] = { - "name": "properties/sample1/searchAds360Links/sample2", - "advertiser_id": "advertiser_id_value", - "campaign_data_sharing_enabled": {"value": True}, - "cost_data_sharing_enabled": {}, - "advertiser_display_name": "advertiser_display_name_value", - "ads_personalization_enabled": {}, - "site_stats_sharing_enabled": {}, - } - # 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 = analytics_admin.UpdateSearchAds360LinkRequest.meta.fields[ - "search_ads_360_link" - ] - - 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["search_ads_360_link"].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["search_ads_360_link"][field])): - del request_init["search_ads_360_link"][field][i][subfield] - else: - del request_init["search_ads_360_link"][field][subfield] + request_init = {"parent": "accounts/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.SearchAds360Link( - name="name_value", - advertiser_id="advertiser_id_value", - advertiser_display_name="advertiser_display_name_value", - ) + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = analytics_admin.BatchUpdateAccessBindingsResponse() # 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.SearchAds360Link.pb(return_value) + return_value = analytics_admin.BatchUpdateAccessBindingsResponse.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_search_ads360_link(request) + response = client.batch_update_access_bindings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.SearchAds360Link) - assert response.name == "name_value" - assert response.advertiser_id == "advertiser_id_value" - assert response.advertiser_display_name == "advertiser_display_name_value" + assert isinstance(response, analytics_admin.BatchUpdateAccessBindingsResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_search_ads360_link_rest_interceptors(null_interceptor): +def test_batch_update_access_bindings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -106344,18 +111918,19 @@ def test_update_search_ads360_link_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_search_ads360_link", + "post_batch_update_access_bindings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_search_ads360_link_with_metadata", + "post_batch_update_access_bindings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_search_ads360_link" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_batch_update_access_bindings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateSearchAds360LinkRequest.pb( - analytics_admin.UpdateSearchAds360LinkRequest() + pb_message = analytics_admin.BatchUpdateAccessBindingsRequest.pb( + analytics_admin.BatchUpdateAccessBindingsRequest() ) transcode.return_value = { "method": "post", @@ -106367,19 +111942,24 @@ def test_update_search_ads360_link_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.SearchAds360Link.to_json(resources.SearchAds360Link()) + return_value = analytics_admin.BatchUpdateAccessBindingsResponse.to_json( + analytics_admin.BatchUpdateAccessBindingsResponse() + ) req.return_value.content = return_value - request = analytics_admin.UpdateSearchAds360LinkRequest() + request = analytics_admin.BatchUpdateAccessBindingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.SearchAds360Link() - post_with_metadata.return_value = resources.SearchAds360Link(), metadata + post.return_value = analytics_admin.BatchUpdateAccessBindingsResponse() + post_with_metadata.return_value = ( + analytics_admin.BatchUpdateAccessBindingsResponse(), + metadata, + ) - client.update_search_ads360_link( + client.batch_update_access_bindings( request, metadata=[ ("key", "val"), @@ -106392,14 +111972,14 @@ def test_update_search_ads360_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_attribution_settings_rest_bad_request( - request_type=analytics_admin.GetAttributionSettingsRequest, +def test_batch_delete_access_bindings_rest_bad_request( + request_type=analytics_admin.BatchDeleteAccessBindingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/attributionSettings"} + request_init = {"parent": "accounts/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -106414,71 +111994,45 @@ def test_get_attribution_settings_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_attribution_settings(request) + client.batch_delete_access_bindings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetAttributionSettingsRequest, + analytics_admin.BatchDeleteAccessBindingsRequest, dict, ], ) -def test_get_attribution_settings_rest_call_success(request_type): +def test_batch_delete_access_bindings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/attributionSettings"} + request_init = {"parent": "accounts/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.AttributionSettings( - name="name_value", - acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, - other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, - reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, - ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, - ) + return_value = None # 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.AttributionSettings.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"} - response = client.get_attribution_settings(request) + response = client.batch_delete_access_bindings(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.AttributionSettings) - assert response.name == "name_value" - assert ( - response.acquisition_conversion_event_lookback_window - == resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS - ) - assert ( - response.other_conversion_event_lookback_window - == resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS - ) - assert ( - response.reporting_attribution_model - == resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN - ) - assert ( - response.ads_web_conversion_data_export_scope - == resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET - ) + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_attribution_settings_rest_interceptors(null_interceptor): +def test_batch_delete_access_bindings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -106492,18 +112046,12 @@ def test_get_attribution_settings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_attribution_settings" - ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_attribution_settings_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_attribution_settings" + "pre_batch_delete_access_bindings", ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetAttributionSettingsRequest.pb( - analytics_admin.GetAttributionSettingsRequest() + pb_message = analytics_admin.BatchDeleteAccessBindingsRequest.pb( + analytics_admin.BatchDeleteAccessBindingsRequest() ) transcode.return_value = { "method": "post", @@ -106515,21 +112063,15 @@ def test_get_attribution_settings_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.AttributionSettings.to_json( - resources.AttributionSettings() - ) - req.return_value.content = return_value - request = analytics_admin.GetAttributionSettingsRequest() + request = analytics_admin.BatchDeleteAccessBindingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.AttributionSettings() - post_with_metadata.return_value = resources.AttributionSettings(), metadata - client.get_attribution_settings( + client.batch_delete_access_bindings( request, metadata=[ ("key", "val"), @@ -106538,20 +112080,16 @@ def test_get_attribution_settings_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_update_attribution_settings_rest_bad_request( - request_type=analytics_admin.UpdateAttributionSettingsRequest, +def test_get_expanded_data_set_rest_bad_request( + request_type=analytics_admin.GetExpandedDataSetRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "attribution_settings": {"name": "properties/sample1/attributionSettings"} - } + request_init = {"name": "properties/sample1/expandedDataSets/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -106566,114 +112104,34 @@ def test_update_attribution_settings_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_attribution_settings(request) + client.get_expanded_data_set(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateAttributionSettingsRequest, + analytics_admin.GetExpandedDataSetRequest, dict, ], ) -def test_update_attribution_settings_rest_call_success(request_type): +def test_get_expanded_data_set_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "attribution_settings": {"name": "properties/sample1/attributionSettings"} - } - request_init["attribution_settings"] = { - "name": "properties/sample1/attributionSettings", - "acquisition_conversion_event_lookback_window": 1, - "other_conversion_event_lookback_window": 1, - "reporting_attribution_model": 1, - "ads_web_conversion_data_export_scope": 1, - } - # 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 = analytics_admin.UpdateAttributionSettingsRequest.meta.fields[ - "attribution_settings" - ] - - 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[ - "attribution_settings" - ].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["attribution_settings"][field])): - del request_init["attribution_settings"][field][i][subfield] - else: - del request_init["attribution_settings"][field][subfield] + request_init = {"name": "properties/sample1/expandedDataSets/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 = resources.AttributionSettings( + return_value = expanded_data_set.ExpandedDataSet( name="name_value", - acquisition_conversion_event_lookback_window=resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS, - other_conversion_event_lookback_window=resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS, - reporting_attribution_model=resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN, - ads_web_conversion_data_export_scope=resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET, + display_name="display_name_value", + description="description_value", + dimension_names=["dimension_names_value"], + metric_names=["metric_names_value"], ) # Wrap the value into a proper Response obj @@ -106681,36 +112139,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AttributionSettings.pb(return_value) + return_value = expanded_data_set.ExpandedDataSet.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_attribution_settings(request) + response = client.get_expanded_data_set(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.AttributionSettings) + assert isinstance(response, expanded_data_set.ExpandedDataSet) assert response.name == "name_value" - assert ( - response.acquisition_conversion_event_lookback_window - == resources.AttributionSettings.AcquisitionConversionEventLookbackWindow.ACQUISITION_CONVERSION_EVENT_LOOKBACK_WINDOW_7_DAYS - ) - assert ( - response.other_conversion_event_lookback_window - == resources.AttributionSettings.OtherConversionEventLookbackWindow.OTHER_CONVERSION_EVENT_LOOKBACK_WINDOW_30_DAYS - ) - assert ( - response.reporting_attribution_model - == resources.AttributionSettings.ReportingAttributionModel.PAID_AND_ORGANIC_CHANNELS_DATA_DRIVEN - ) - assert ( - response.ads_web_conversion_data_export_scope - == resources.AttributionSettings.AdsWebConversionDataExportScope.NOT_SELECTED_YET - ) + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.dimension_names == ["dimension_names_value"] + assert response.metric_names == ["metric_names_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_attribution_settings_rest_interceptors(null_interceptor): +def test_get_expanded_data_set_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -106724,20 +112170,18 @@ def test_update_attribution_settings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_attribution_settings", + transports.AnalyticsAdminServiceRestInterceptor, "post_get_expanded_data_set" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_attribution_settings_with_metadata", + "post_get_expanded_data_set_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_attribution_settings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_expanded_data_set" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateAttributionSettingsRequest.pb( - analytics_admin.UpdateAttributionSettingsRequest() + pb_message = analytics_admin.GetExpandedDataSetRequest.pb( + analytics_admin.GetExpandedDataSetRequest() ) transcode.return_value = { "method": "post", @@ -106749,21 +112193,21 @@ def test_update_attribution_settings_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.AttributionSettings.to_json( - resources.AttributionSettings() + return_value = expanded_data_set.ExpandedDataSet.to_json( + expanded_data_set.ExpandedDataSet() ) req.return_value.content = return_value - request = analytics_admin.UpdateAttributionSettingsRequest() + request = analytics_admin.GetExpandedDataSetRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.AttributionSettings() - post_with_metadata.return_value = resources.AttributionSettings(), metadata + post.return_value = expanded_data_set.ExpandedDataSet() + post_with_metadata.return_value = expanded_data_set.ExpandedDataSet(), metadata - client.update_attribution_settings( + client.get_expanded_data_set( request, metadata=[ ("key", "val"), @@ -106776,14 +112220,14 @@ def test_update_attribution_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_run_access_report_rest_bad_request( - request_type=analytics_admin.RunAccessReportRequest, +def test_list_expanded_data_sets_rest_bad_request( + request_type=analytics_admin.ListExpandedDataSetsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"entity": "properties/sample1"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -106798,30 +112242,30 @@ def test_run_access_report_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.run_access_report(request) + client.list_expanded_data_sets(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.RunAccessReportRequest, + analytics_admin.ListExpandedDataSetsRequest, dict, ], ) -def test_run_access_report_rest_call_success(request_type): +def test_list_expanded_data_sets_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"entity": "properties/sample1"} + request_init = {"parent": "properties/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 = analytics_admin.RunAccessReportResponse( - row_count=992, + return_value = analytics_admin.ListExpandedDataSetsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -106829,20 +112273,20 @@ def test_run_access_report_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.RunAccessReportResponse.pb(return_value) + return_value = analytics_admin.ListExpandedDataSetsResponse.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.run_access_report(request) + response = client.list_expanded_data_sets(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.RunAccessReportResponse) - assert response.row_count == 992 + assert isinstance(response, pagers.ListExpandedDataSetsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_run_access_report_rest_interceptors(null_interceptor): +def test_list_expanded_data_sets_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -106856,18 +112300,18 @@ def test_run_access_report_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_run_access_report" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_expanded_data_sets" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_run_access_report_with_metadata", + "post_list_expanded_data_sets_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_run_access_report" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_expanded_data_sets" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.RunAccessReportRequest.pb( - analytics_admin.RunAccessReportRequest() + pb_message = analytics_admin.ListExpandedDataSetsRequest.pb( + analytics_admin.ListExpandedDataSetsRequest() ) transcode.return_value = { "method": "post", @@ -106879,24 +112323,24 @@ def test_run_access_report_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 = analytics_admin.RunAccessReportResponse.to_json( - analytics_admin.RunAccessReportResponse() + return_value = analytics_admin.ListExpandedDataSetsResponse.to_json( + analytics_admin.ListExpandedDataSetsResponse() ) req.return_value.content = return_value - request = analytics_admin.RunAccessReportRequest() + request = analytics_admin.ListExpandedDataSetsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.RunAccessReportResponse() + post.return_value = analytics_admin.ListExpandedDataSetsResponse() post_with_metadata.return_value = ( - analytics_admin.RunAccessReportResponse(), + analytics_admin.ListExpandedDataSetsResponse(), metadata, ) - client.run_access_report( + client.list_expanded_data_sets( request, metadata=[ ("key", "val"), @@ -106909,14 +112353,14 @@ def test_run_access_report_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_access_binding_rest_bad_request( - request_type=analytics_admin.CreateAccessBindingRequest, +def test_create_expanded_data_set_rest_bad_request( + request_type=analytics_admin.CreateExpandedDataSetRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -106931,237 +112375,127 @@ def test_create_access_binding_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_access_binding(request) + client.create_expanded_data_set(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateAccessBindingRequest, + analytics_admin.CreateExpandedDataSetRequest, dict, ], ) -def test_create_access_binding_rest_call_success(request_type): +def test_create_expanded_data_set_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} - request_init["access_binding"] = { - "user": "user_value", + request_init = {"parent": "properties/sample1"} + request_init["expanded_data_set"] = { "name": "name_value", - "roles": ["roles_value1", "roles_value2"], + "display_name": "display_name_value", + "description": "description_value", + "dimension_names": ["dimension_names_value1", "dimension_names_value2"], + "metric_names": ["metric_names_value1", "metric_names_value2"], + "dimension_filter_expression": { + "and_group": {"filter_expressions": {}}, + "not_expression": {}, + "filter": { + "string_filter": { + "match_type": 1, + "value": "value_value", + "case_sensitive": True, + }, + "in_list_filter": { + "values": ["values_value1", "values_value2"], + "case_sensitive": True, + }, + "field_name": "field_name_value", + }, + }, + "data_collection_start_time": {"seconds": 751, "nanos": 543}, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateAccessBindingRequest.meta.fields[ - "access_binding" + test_field = analytics_admin.CreateExpandedDataSetRequest.meta.fields[ + "expanded_data_set" ] 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["access_binding"].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["access_binding"][field])): - del request_init["access_binding"][field][i][subfield] - else: - del request_init["access_binding"][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 = resources.AccessBinding( - name="name_value", - roles=["roles_value"], - user="user_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.AccessBinding.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.create_access_binding(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, resources.AccessBinding) - assert response.name == "name_value" - assert response.roles == ["roles_value"] - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_access_binding_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_create_access_binding" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_access_binding_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_access_binding" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateAccessBindingRequest.pb( - analytics_admin.CreateAccessBindingRequest() - ) - 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.AccessBinding.to_json(resources.AccessBinding()) - req.return_value.content = return_value - - request = analytics_admin.CreateAccessBindingRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = resources.AccessBinding() - post_with_metadata.return_value = resources.AccessBinding(), metadata - - client.create_access_binding( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) + # 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 = [] - pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() + 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 -def test_get_access_binding_rest_bad_request( - request_type=analytics_admin.GetAccessBindingRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1/accessBindings/sample2"} - request = request_type(**request_init) + runtime_nested_fields = [ + (field.name, nested_field.name) + for field in get_message_fields(test_field) + for nested_field in get_message_fields(field) + ] - # 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_access_binding(request) + 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["expanded_data_set"].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 -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.GetAccessBindingRequest, - dict, - ], -) -def test_get_access_binding_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + 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, + } + ) - # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1/accessBindings/sample2"} + # 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["expanded_data_set"][field])): + del request_init["expanded_data_set"][field][i][subfield] + else: + del request_init["expanded_data_set"][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 = resources.AccessBinding( + return_value = gaa_expanded_data_set.ExpandedDataSet( name="name_value", - roles=["roles_value"], - user="user_value", + display_name="display_name_value", + description="description_value", + dimension_names=["dimension_names_value"], + metric_names=["metric_names_value"], ) # Wrap the value into a proper Response obj @@ -107169,21 +112503,24 @@ def test_get_access_binding_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = gaa_expanded_data_set.ExpandedDataSet.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_access_binding(request) + response = client.create_expanded_data_set(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.AccessBinding) + assert isinstance(response, gaa_expanded_data_set.ExpandedDataSet) assert response.name == "name_value" - assert response.roles == ["roles_value"] + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.dimension_names == ["dimension_names_value"] + assert response.metric_names == ["metric_names_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_access_binding_rest_interceptors(null_interceptor): +def test_create_expanded_data_set_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -107197,18 +112534,18 @@ def test_get_access_binding_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_access_binding" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_expanded_data_set" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_access_binding_with_metadata", + "post_create_expanded_data_set_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_access_binding" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_expanded_data_set" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetAccessBindingRequest.pb( - analytics_admin.GetAccessBindingRequest() + pb_message = analytics_admin.CreateExpandedDataSetRequest.pb( + analytics_admin.CreateExpandedDataSetRequest() ) transcode.return_value = { "method": "post", @@ -107220,19 +112557,24 @@ def test_get_access_binding_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.AccessBinding.to_json(resources.AccessBinding()) + return_value = gaa_expanded_data_set.ExpandedDataSet.to_json( + gaa_expanded_data_set.ExpandedDataSet() + ) req.return_value.content = return_value - request = analytics_admin.GetAccessBindingRequest() + request = analytics_admin.CreateExpandedDataSetRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.AccessBinding() - post_with_metadata.return_value = resources.AccessBinding(), metadata + post.return_value = gaa_expanded_data_set.ExpandedDataSet() + post_with_metadata.return_value = ( + gaa_expanded_data_set.ExpandedDataSet(), + metadata, + ) - client.get_access_binding( + client.create_expanded_data_set( request, metadata=[ ("key", "val"), @@ -107245,15 +112587,15 @@ def test_get_access_binding_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_access_binding_rest_bad_request( - request_type=analytics_admin.UpdateAccessBindingRequest, +def test_update_expanded_data_set_rest_bad_request( + request_type=analytics_admin.UpdateExpandedDataSetRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "access_binding": {"name": "accounts/sample1/accessBindings/sample2"} + "expanded_data_set": {"name": "properties/sample1/expandedDataSets/sample2"} } request = request_type(**request_init) @@ -107269,37 +112611,56 @@ def test_update_access_binding_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_access_binding(request) + client.update_expanded_data_set(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateAccessBindingRequest, + analytics_admin.UpdateExpandedDataSetRequest, dict, ], ) -def test_update_access_binding_rest_call_success(request_type): +def test_update_expanded_data_set_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "access_binding": {"name": "accounts/sample1/accessBindings/sample2"} + "expanded_data_set": {"name": "properties/sample1/expandedDataSets/sample2"} } - request_init["access_binding"] = { - "user": "user_value", - "name": "accounts/sample1/accessBindings/sample2", - "roles": ["roles_value1", "roles_value2"], + request_init["expanded_data_set"] = { + "name": "properties/sample1/expandedDataSets/sample2", + "display_name": "display_name_value", + "description": "description_value", + "dimension_names": ["dimension_names_value1", "dimension_names_value2"], + "metric_names": ["metric_names_value1", "metric_names_value2"], + "dimension_filter_expression": { + "and_group": {"filter_expressions": {}}, + "not_expression": {}, + "filter": { + "string_filter": { + "match_type": 1, + "value": "value_value", + "case_sensitive": True, + }, + "in_list_filter": { + "values": ["values_value1", "values_value2"], + "case_sensitive": True, + }, + "field_name": "field_name_value", + }, + }, + "data_collection_start_time": {"seconds": 751, "nanos": 543}, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateAccessBindingRequest.meta.fields[ - "access_binding" + test_field = analytics_admin.UpdateExpandedDataSetRequest.meta.fields[ + "expanded_data_set" ] def get_message_fields(field): @@ -107328,7 +112689,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["access_binding"].items(): # pragma: NO COVER + for field, value in request_init["expanded_data_set"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -107358,19 +112719,21 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["access_binding"][field])): - del request_init["access_binding"][field][i][subfield] + for i in range(0, len(request_init["expanded_data_set"][field])): + del request_init["expanded_data_set"][field][i][subfield] else: - del request_init["access_binding"][field][subfield] + del request_init["expanded_data_set"][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 = resources.AccessBinding( + return_value = gaa_expanded_data_set.ExpandedDataSet( name="name_value", - roles=["roles_value"], - user="user_value", + display_name="display_name_value", + description="description_value", + dimension_names=["dimension_names_value"], + metric_names=["metric_names_value"], ) # Wrap the value into a proper Response obj @@ -107378,21 +112741,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AccessBinding.pb(return_value) + return_value = gaa_expanded_data_set.ExpandedDataSet.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_access_binding(request) + response = client.update_expanded_data_set(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.AccessBinding) + assert isinstance(response, gaa_expanded_data_set.ExpandedDataSet) assert response.name == "name_value" - assert response.roles == ["roles_value"] + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.dimension_names == ["dimension_names_value"] + assert response.metric_names == ["metric_names_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_access_binding_rest_interceptors(null_interceptor): +def test_update_expanded_data_set_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -107406,18 +112772,18 @@ def test_update_access_binding_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_access_binding" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_expanded_data_set" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_access_binding_with_metadata", + "post_update_expanded_data_set_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_access_binding" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_expanded_data_set" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateAccessBindingRequest.pb( - analytics_admin.UpdateAccessBindingRequest() + pb_message = analytics_admin.UpdateExpandedDataSetRequest.pb( + analytics_admin.UpdateExpandedDataSetRequest() ) transcode.return_value = { "method": "post", @@ -107429,19 +112795,24 @@ def test_update_access_binding_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.AccessBinding.to_json(resources.AccessBinding()) + return_value = gaa_expanded_data_set.ExpandedDataSet.to_json( + gaa_expanded_data_set.ExpandedDataSet() + ) req.return_value.content = return_value - request = analytics_admin.UpdateAccessBindingRequest() + request = analytics_admin.UpdateExpandedDataSetRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.AccessBinding() - post_with_metadata.return_value = resources.AccessBinding(), metadata + post.return_value = gaa_expanded_data_set.ExpandedDataSet() + post_with_metadata.return_value = ( + gaa_expanded_data_set.ExpandedDataSet(), + metadata, + ) - client.update_access_binding( + client.update_expanded_data_set( request, metadata=[ ("key", "val"), @@ -107454,14 +112825,14 @@ def test_update_access_binding_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_access_binding_rest_bad_request( - request_type=analytics_admin.DeleteAccessBindingRequest, +def test_delete_expanded_data_set_rest_bad_request( + request_type=analytics_admin.DeleteExpandedDataSetRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1/accessBindings/sample2"} + request_init = {"name": "properties/sample1/expandedDataSets/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -107476,23 +112847,23 @@ def test_delete_access_binding_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_access_binding(request) + client.delete_expanded_data_set(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteAccessBindingRequest, + analytics_admin.DeleteExpandedDataSetRequest, dict, ], ) -def test_delete_access_binding_rest_call_success(request_type): +def test_delete_expanded_data_set_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "accounts/sample1/accessBindings/sample2"} + request_init = {"name": "properties/sample1/expandedDataSets/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -107507,14 +112878,14 @@ def test_delete_access_binding_rest_call_success(request_type): 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_access_binding(request) + response = client.delete_expanded_data_set(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_access_binding_rest_interceptors(null_interceptor): +def test_delete_expanded_data_set_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -107528,11 +112899,11 @@ def test_delete_access_binding_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_access_binding" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_expanded_data_set" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteAccessBindingRequest.pb( - analytics_admin.DeleteAccessBindingRequest() + pb_message = analytics_admin.DeleteExpandedDataSetRequest.pb( + analytics_admin.DeleteExpandedDataSetRequest() ) transcode.return_value = { "method": "post", @@ -107545,14 +112916,14 @@ def test_delete_access_binding_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.DeleteAccessBindingRequest() + request = analytics_admin.DeleteExpandedDataSetRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_access_binding( + client.delete_expanded_data_set( request, metadata=[ ("key", "val"), @@ -107563,14 +112934,14 @@ def test_delete_access_binding_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_list_access_bindings_rest_bad_request( - request_type=analytics_admin.ListAccessBindingsRequest, +def test_get_channel_group_rest_bad_request( + request_type=analytics_admin.GetChannelGroupRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = {"name": "properties/sample1/channelGroups/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -107585,30 +112956,34 @@ def test_list_access_bindings_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.list_access_bindings(request) + client.get_channel_group(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListAccessBindingsRequest, + analytics_admin.GetChannelGroupRequest, dict, ], ) -def test_list_access_bindings_rest_call_success(request_type): +def test_get_channel_group_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = {"name": "properties/sample1/channelGroups/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 = analytics_admin.ListAccessBindingsResponse( - next_page_token="next_page_token_value", + return_value = channel_group.ChannelGroup( + name="name_value", + display_name="display_name_value", + description="description_value", + system_defined=True, + primary=True, ) # Wrap the value into a proper Response obj @@ -107616,20 +112991,24 @@ def test_list_access_bindings_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAccessBindingsResponse.pb(return_value) + return_value = channel_group.ChannelGroup.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_access_bindings(request) + response = client.get_channel_group(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAccessBindingsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, channel_group.ChannelGroup) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.system_defined is True + assert response.primary is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_access_bindings_rest_interceptors(null_interceptor): +def test_get_channel_group_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -107643,18 +113022,18 @@ def test_list_access_bindings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_access_bindings" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_channel_group" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_access_bindings_with_metadata", + "post_get_channel_group_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_access_bindings" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_channel_group" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListAccessBindingsRequest.pb( - analytics_admin.ListAccessBindingsRequest() + pb_message = analytics_admin.GetChannelGroupRequest.pb( + analytics_admin.GetChannelGroupRequest() ) transcode.return_value = { "method": "post", @@ -107666,24 +113045,19 @@ def test_list_access_bindings_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 = analytics_admin.ListAccessBindingsResponse.to_json( - analytics_admin.ListAccessBindingsResponse() - ) + return_value = channel_group.ChannelGroup.to_json(channel_group.ChannelGroup()) req.return_value.content = return_value - request = analytics_admin.ListAccessBindingsRequest() + request = analytics_admin.GetChannelGroupRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListAccessBindingsResponse() - post_with_metadata.return_value = ( - analytics_admin.ListAccessBindingsResponse(), - metadata, - ) + post.return_value = channel_group.ChannelGroup() + post_with_metadata.return_value = channel_group.ChannelGroup(), metadata - client.list_access_bindings( + client.get_channel_group( request, metadata=[ ("key", "val"), @@ -107696,14 +113070,14 @@ def test_list_access_bindings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_batch_create_access_bindings_rest_bad_request( - request_type=analytics_admin.BatchCreateAccessBindingsRequest, +def test_list_channel_groups_rest_bad_request( + request_type=analytics_admin.ListChannelGroupsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -107718,50 +113092,51 @@ def test_batch_create_access_bindings_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.batch_create_access_bindings(request) + client.list_channel_groups(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.BatchCreateAccessBindingsRequest, + analytics_admin.ListChannelGroupsRequest, dict, ], ) -def test_batch_create_access_bindings_rest_call_success(request_type): +def test_list_channel_groups_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = {"parent": "properties/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 = analytics_admin.BatchCreateAccessBindingsResponse() + return_value = analytics_admin.ListChannelGroupsResponse( + 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 = analytics_admin.BatchCreateAccessBindingsResponse.pb( - return_value - ) + return_value = analytics_admin.ListChannelGroupsResponse.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.batch_create_access_bindings(request) + response = client.list_channel_groups(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.BatchCreateAccessBindingsResponse) + assert isinstance(response, pagers.ListChannelGroupsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_batch_create_access_bindings_rest_interceptors(null_interceptor): +def test_list_channel_groups_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -107775,20 +113150,18 @@ def test_batch_create_access_bindings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_batch_create_access_bindings", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_channel_groups" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_batch_create_access_bindings_with_metadata", + "post_list_channel_groups_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_batch_create_access_bindings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_channel_groups" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.BatchCreateAccessBindingsRequest.pb( - analytics_admin.BatchCreateAccessBindingsRequest() + pb_message = analytics_admin.ListChannelGroupsRequest.pb( + analytics_admin.ListChannelGroupsRequest() ) transcode.return_value = { "method": "post", @@ -107800,24 +113173,24 @@ def test_batch_create_access_bindings_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 = analytics_admin.BatchCreateAccessBindingsResponse.to_json( - analytics_admin.BatchCreateAccessBindingsResponse() + return_value = analytics_admin.ListChannelGroupsResponse.to_json( + analytics_admin.ListChannelGroupsResponse() ) req.return_value.content = return_value - request = analytics_admin.BatchCreateAccessBindingsRequest() + request = analytics_admin.ListChannelGroupsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.BatchCreateAccessBindingsResponse() + post.return_value = analytics_admin.ListChannelGroupsResponse() post_with_metadata.return_value = ( - analytics_admin.BatchCreateAccessBindingsResponse(), + analytics_admin.ListChannelGroupsResponse(), metadata, ) - client.batch_create_access_bindings( + client.list_channel_groups( request, metadata=[ ("key", "val"), @@ -107830,14 +113203,14 @@ def test_batch_create_access_bindings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_batch_get_access_bindings_rest_bad_request( - request_type=analytics_admin.BatchGetAccessBindingsRequest, +def test_create_channel_group_rest_bad_request( + request_type=analytics_admin.CreateChannelGroupRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -107852,181 +113225,150 @@ def test_batch_get_access_bindings_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.batch_get_access_bindings(request) + client.create_channel_group(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.BatchGetAccessBindingsRequest, + analytics_admin.CreateChannelGroupRequest, dict, ], ) -def test_batch_get_access_bindings_rest_call_success(request_type): +def test_create_channel_group_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/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 = analytics_admin.BatchGetAccessBindingsResponse() - - # 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 = analytics_admin.BatchGetAccessBindingsResponse.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.batch_get_access_bindings(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.BatchGetAccessBindingsResponse) - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_batch_get_access_bindings_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, - "post_batch_get_access_bindings", - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_batch_get_access_bindings_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_batch_get_access_bindings" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.BatchGetAccessBindingsRequest.pb( - analytics_admin.BatchGetAccessBindingsRequest() - ) - 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 = analytics_admin.BatchGetAccessBindingsResponse.to_json( - analytics_admin.BatchGetAccessBindingsResponse() - ) - req.return_value.content = return_value - - request = analytics_admin.BatchGetAccessBindingsRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = analytics_admin.BatchGetAccessBindingsResponse() - post_with_metadata.return_value = ( - analytics_admin.BatchGetAccessBindingsResponse(), - metadata, - ) + request_init = {"parent": "properties/sample1"} + request_init["channel_group"] = { + "name": "name_value", + "display_name": "display_name_value", + "description": "description_value", + "grouping_rule": [ + { + "display_name": "display_name_value", + "expression": { + "and_group": {"filter_expressions": {}}, + "or_group": {}, + "not_expression": {}, + "filter": { + "string_filter": {"match_type": 1, "value": "value_value"}, + "in_list_filter": { + "values": ["values_value1", "values_value2"] + }, + "field_name": "field_name_value", + }, + }, + } + ], + "system_defined": True, + "primary": True, + } + # 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 - client.batch_get_access_bindings( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.CreateChannelGroupRequest.meta.fields["channel_group"] - pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() + def get_message_fields(field): + # Given a field which is a message (composite type), return a list with + # all the fields of the message. + # If the field is not a composite type, return an empty list. + message_fields = [] + if hasattr(field, "message") and field.message: + is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") -def test_batch_update_access_bindings_rest_bad_request( - request_type=analytics_admin.BatchUpdateAccessBindingsRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} - request = request_type(**request_init) + 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 - # 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.batch_update_access_bindings(request) + 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 = [] -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.BatchUpdateAccessBindingsRequest, - dict, - ], -) -def test_batch_update_access_bindings_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) + # For each item in the sample request, create a list of sub fields which are not present at runtime + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for field, value in request_init["channel_group"].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 - # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + 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["channel_group"][field])): + del request_init["channel_group"][field][i][subfield] + else: + del request_init["channel_group"][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 = analytics_admin.BatchUpdateAccessBindingsResponse() + return_value = gaa_channel_group.ChannelGroup( + name="name_value", + display_name="display_name_value", + description="description_value", + system_defined=True, + primary=True, + ) # 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 = analytics_admin.BatchUpdateAccessBindingsResponse.pb( - return_value - ) + return_value = gaa_channel_group.ChannelGroup.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.batch_update_access_bindings(request) + response = client.create_channel_group(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.BatchUpdateAccessBindingsResponse) + assert isinstance(response, gaa_channel_group.ChannelGroup) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.system_defined is True + assert response.primary is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_batch_update_access_bindings_rest_interceptors(null_interceptor): +def test_create_channel_group_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -108040,20 +113382,18 @@ def test_batch_update_access_bindings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_batch_update_access_bindings", + transports.AnalyticsAdminServiceRestInterceptor, "post_create_channel_group" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_batch_update_access_bindings_with_metadata", + "post_create_channel_group_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_batch_update_access_bindings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_channel_group" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.BatchUpdateAccessBindingsRequest.pb( - analytics_admin.BatchUpdateAccessBindingsRequest() + pb_message = analytics_admin.CreateChannelGroupRequest.pb( + analytics_admin.CreateChannelGroupRequest() ) transcode.return_value = { "method": "post", @@ -108065,24 +113405,21 @@ def test_batch_update_access_bindings_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 = analytics_admin.BatchUpdateAccessBindingsResponse.to_json( - analytics_admin.BatchUpdateAccessBindingsResponse() + return_value = gaa_channel_group.ChannelGroup.to_json( + gaa_channel_group.ChannelGroup() ) req.return_value.content = return_value - request = analytics_admin.BatchUpdateAccessBindingsRequest() + request = analytics_admin.CreateChannelGroupRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.BatchUpdateAccessBindingsResponse() - post_with_metadata.return_value = ( - analytics_admin.BatchUpdateAccessBindingsResponse(), - metadata, - ) + post.return_value = gaa_channel_group.ChannelGroup() + post_with_metadata.return_value = gaa_channel_group.ChannelGroup(), metadata - client.batch_update_access_bindings( + client.create_channel_group( request, metadata=[ ("key", "val"), @@ -108095,14 +113432,16 @@ def test_batch_update_access_bindings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_batch_delete_access_bindings_rest_bad_request( - request_type=analytics_admin.BatchDeleteAccessBindingsRequest, +def test_update_channel_group_rest_bad_request( + request_type=analytics_admin.UpdateChannelGroupRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = { + "channel_group": {"name": "properties/sample1/channelGroups/sample2"} + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -108117,45 +113456,152 @@ def test_batch_delete_access_bindings_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.batch_delete_access_bindings(request) + client.update_channel_group(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.BatchDeleteAccessBindingsRequest, + analytics_admin.UpdateChannelGroupRequest, dict, ], ) -def test_batch_delete_access_bindings_rest_call_success(request_type): +def test_update_channel_group_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "accounts/sample1"} + request_init = { + "channel_group": {"name": "properties/sample1/channelGroups/sample2"} + } + request_init["channel_group"] = { + "name": "properties/sample1/channelGroups/sample2", + "display_name": "display_name_value", + "description": "description_value", + "grouping_rule": [ + { + "display_name": "display_name_value", + "expression": { + "and_group": {"filter_expressions": {}}, + "or_group": {}, + "not_expression": {}, + "filter": { + "string_filter": {"match_type": 1, "value": "value_value"}, + "in_list_filter": { + "values": ["values_value1", "values_value2"] + }, + "field_name": "field_name_value", + }, + }, + } + ], + "system_defined": True, + "primary": True, + } + # 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 = analytics_admin.UpdateChannelGroupRequest.meta.fields["channel_group"] + + 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["channel_group"].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["channel_group"][field])): + del request_init["channel_group"][field][i][subfield] + else: + del request_init["channel_group"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = gaa_channel_group.ChannelGroup( + name="name_value", + display_name="display_name_value", + description="description_value", + system_defined=True, + primary=True, + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = gaa_channel_group.ChannelGroup.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.batch_delete_access_bindings(request) + response = client.update_channel_group(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, gaa_channel_group.ChannelGroup) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.description == "description_value" + assert response.system_defined is True + assert response.primary is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_batch_delete_access_bindings_rest_interceptors(null_interceptor): +def test_update_channel_group_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -108169,12 +113615,18 @@ def test_batch_delete_access_bindings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "post_update_channel_group" + ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_batch_delete_access_bindings", + "post_update_channel_group_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_channel_group" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.BatchDeleteAccessBindingsRequest.pb( - analytics_admin.BatchDeleteAccessBindingsRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdateChannelGroupRequest.pb( + analytics_admin.UpdateChannelGroupRequest() ) transcode.return_value = { "method": "post", @@ -108186,15 +113638,21 @@ def test_batch_delete_access_bindings_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 = gaa_channel_group.ChannelGroup.to_json( + gaa_channel_group.ChannelGroup() + ) + req.return_value.content = return_value - request = analytics_admin.BatchDeleteAccessBindingsRequest() + request = analytics_admin.UpdateChannelGroupRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = gaa_channel_group.ChannelGroup() + post_with_metadata.return_value = gaa_channel_group.ChannelGroup(), metadata - client.batch_delete_access_bindings( + client.update_channel_group( request, metadata=[ ("key", "val"), @@ -108203,16 +113661,18 @@ def test_batch_delete_access_bindings_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_get_expanded_data_set_rest_bad_request( - request_type=analytics_admin.GetExpandedDataSetRequest, +def test_delete_channel_group_rest_bad_request( + request_type=analytics_admin.DeleteChannelGroupRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/expandedDataSets/sample2"} + request_init = {"name": "properties/sample1/channelGroups/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -108227,59 +113687,45 @@ def test_get_expanded_data_set_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_expanded_data_set(request) + client.delete_channel_group(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetExpandedDataSetRequest, + analytics_admin.DeleteChannelGroupRequest, dict, ], ) -def test_get_expanded_data_set_rest_call_success(request_type): +def test_delete_channel_group_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/expandedDataSets/sample2"} + request_init = {"name": "properties/sample1/channelGroups/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 = expanded_data_set.ExpandedDataSet( - name="name_value", - display_name="display_name_value", - description="description_value", - dimension_names=["dimension_names_value"], - metric_names=["metric_names_value"], - ) + return_value = None # 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 = expanded_data_set.ExpandedDataSet.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"} - response = client.get_expanded_data_set(request) + response = client.delete_channel_group(request) # Establish that the response is the type that we expect. - assert isinstance(response, expanded_data_set.ExpandedDataSet) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.dimension_names == ["dimension_names_value"] - assert response.metric_names == ["metric_names_value"] + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_expanded_data_set_rest_interceptors(null_interceptor): +def test_delete_channel_group_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -108293,18 +113739,11 @@ def test_get_expanded_data_set_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_expanded_data_set" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_expanded_data_set_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_expanded_data_set" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_channel_group" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetExpandedDataSetRequest.pb( - analytics_admin.GetExpandedDataSetRequest() + pb_message = analytics_admin.DeleteChannelGroupRequest.pb( + analytics_admin.DeleteChannelGroupRequest() ) transcode.return_value = { "method": "post", @@ -108316,21 +113755,15 @@ def test_get_expanded_data_set_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 = expanded_data_set.ExpandedDataSet.to_json( - expanded_data_set.ExpandedDataSet() - ) - req.return_value.content = return_value - request = analytics_admin.GetExpandedDataSetRequest() + request = analytics_admin.DeleteChannelGroupRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = expanded_data_set.ExpandedDataSet() - post_with_metadata.return_value = expanded_data_set.ExpandedDataSet(), metadata - client.get_expanded_data_set( + client.delete_channel_group( request, metadata=[ ("key", "val"), @@ -108339,18 +113772,16 @@ def test_get_expanded_data_set_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_list_expanded_data_sets_rest_bad_request( - request_type=analytics_admin.ListExpandedDataSetsRequest, +def test_set_automated_ga4_configuration_opt_out_rest_bad_request( + request_type=analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -108365,51 +113796,52 @@ def test_list_expanded_data_sets_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.list_expanded_data_sets(request) + client.set_automated_ga4_configuration_opt_out(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListExpandedDataSetsRequest, + analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, dict, ], ) -def test_list_expanded_data_sets_rest_call_success(request_type): +def test_set_automated_ga4_configuration_opt_out_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListExpandedDataSetsResponse( - next_page_token="next_page_token_value", - ) + return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() # 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 = analytics_admin.ListExpandedDataSetsResponse.pb(return_value) + return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.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_expanded_data_sets(request) + response = client.set_automated_ga4_configuration_opt_out(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListExpandedDataSetsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance( + response, analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_expanded_data_sets_rest_interceptors(null_interceptor): +def test_set_automated_ga4_configuration_opt_out_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -108423,18 +113855,20 @@ def test_list_expanded_data_sets_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_expanded_data_sets" + transports.AnalyticsAdminServiceRestInterceptor, + "post_set_automated_ga4_configuration_opt_out", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_expanded_data_sets_with_metadata", + "post_set_automated_ga4_configuration_opt_out_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_expanded_data_sets" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_set_automated_ga4_configuration_opt_out", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListExpandedDataSetsRequest.pb( - analytics_admin.ListExpandedDataSetsRequest() + pb_message = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest.pb( + analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() ) transcode.return_value = { "method": "post", @@ -108446,24 +113880,26 @@ def test_list_expanded_data_sets_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 = analytics_admin.ListExpandedDataSetsResponse.to_json( - analytics_admin.ListExpandedDataSetsResponse() + return_value = ( + analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.to_json( + analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + ) ) req.return_value.content = return_value - request = analytics_admin.ListExpandedDataSetsRequest() + request = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListExpandedDataSetsResponse() + post.return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() post_with_metadata.return_value = ( - analytics_admin.ListExpandedDataSetsResponse(), + analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse(), metadata, ) - client.list_expanded_data_sets( + client.set_automated_ga4_configuration_opt_out( request, metadata=[ ("key", "val"), @@ -108476,14 +113912,14 @@ def test_list_expanded_data_sets_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_expanded_data_set_rest_bad_request( - request_type=analytics_admin.CreateExpandedDataSetRequest, +def test_fetch_automated_ga4_configuration_opt_out_rest_bad_request( + request_type=analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -108498,127 +113934,30 @@ def test_create_expanded_data_set_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_expanded_data_set(request) + client.fetch_automated_ga4_configuration_opt_out(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateExpandedDataSetRequest, - dict, - ], -) -def test_create_expanded_data_set_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["expanded_data_set"] = { - "name": "name_value", - "display_name": "display_name_value", - "description": "description_value", - "dimension_names": ["dimension_names_value1", "dimension_names_value2"], - "metric_names": ["metric_names_value1", "metric_names_value2"], - "dimension_filter_expression": { - "and_group": {"filter_expressions": {}}, - "not_expression": {}, - "filter": { - "string_filter": { - "match_type": 1, - "value": "value_value", - "case_sensitive": True, - }, - "in_list_filter": { - "values": ["values_value1", "values_value2"], - "case_sensitive": True, - }, - "field_name": "field_name_value", - }, - }, - "data_collection_start_time": {"seconds": 751, "nanos": 543}, - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateExpandedDataSetRequest.meta.fields[ - "expanded_data_set" - ] - - 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["expanded_data_set"].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, - } - ) + analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest, + dict, + ], +) +def test_fetch_automated_ga4_configuration_opt_out_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["expanded_data_set"][field])): - del request_init["expanded_data_set"][field][i][subfield] - else: - del request_init["expanded_data_set"][field][subfield] + # 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 = gaa_expanded_data_set.ExpandedDataSet( - name="name_value", - display_name="display_name_value", - description="description_value", - dimension_names=["dimension_names_value"], - metric_names=["metric_names_value"], + return_value = analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse( + opt_out=True, ) # Wrap the value into a proper Response obj @@ -108626,24 +113965,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse.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.create_expanded_data_set(request) + response = client.fetch_automated_ga4_configuration_opt_out(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_expanded_data_set.ExpandedDataSet) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.dimension_names == ["dimension_names_value"] - assert response.metric_names == ["metric_names_value"] + assert isinstance( + response, analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse + ) + assert response.opt_out is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_expanded_data_set_rest_interceptors(null_interceptor): +def test_fetch_automated_ga4_configuration_opt_out_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -108657,18 +113996,20 @@ def test_create_expanded_data_set_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_expanded_data_set" + transports.AnalyticsAdminServiceRestInterceptor, + "post_fetch_automated_ga4_configuration_opt_out", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_expanded_data_set_with_metadata", + "post_fetch_automated_ga4_configuration_opt_out_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_expanded_data_set" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_fetch_automated_ga4_configuration_opt_out", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateExpandedDataSetRequest.pb( - analytics_admin.CreateExpandedDataSetRequest() + pb_message = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest.pb( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() ) transcode.return_value = { "method": "post", @@ -108680,24 +114021,28 @@ def test_create_expanded_data_set_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 = gaa_expanded_data_set.ExpandedDataSet.to_json( - gaa_expanded_data_set.ExpandedDataSet() + return_value = ( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse.to_json( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() + ) ) req.return_value.content = return_value - request = analytics_admin.CreateExpandedDataSetRequest() + request = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_expanded_data_set.ExpandedDataSet() + post.return_value = ( + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() + ) post_with_metadata.return_value = ( - gaa_expanded_data_set.ExpandedDataSet(), + analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse(), metadata, ) - client.create_expanded_data_set( + client.fetch_automated_ga4_configuration_opt_out( request, metadata=[ ("key", "val"), @@ -108710,16 +114055,14 @@ def test_create_expanded_data_set_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_expanded_data_set_rest_bad_request( - request_type=analytics_admin.UpdateExpandedDataSetRequest, +def test_create_big_query_link_rest_bad_request( + request_type=analytics_admin.CreateBigQueryLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "expanded_data_set": {"name": "properties/sample1/expandedDataSets/sample2"} - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -108734,57 +114077,41 @@ def test_update_expanded_data_set_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_expanded_data_set(request) + client.create_big_query_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateExpandedDataSetRequest, + analytics_admin.CreateBigQueryLinkRequest, dict, ], ) -def test_update_expanded_data_set_rest_call_success(request_type): +def test_create_big_query_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "expanded_data_set": {"name": "properties/sample1/expandedDataSets/sample2"} - } - request_init["expanded_data_set"] = { - "name": "properties/sample1/expandedDataSets/sample2", - "display_name": "display_name_value", - "description": "description_value", - "dimension_names": ["dimension_names_value1", "dimension_names_value2"], - "metric_names": ["metric_names_value1", "metric_names_value2"], - "dimension_filter_expression": { - "and_group": {"filter_expressions": {}}, - "not_expression": {}, - "filter": { - "string_filter": { - "match_type": 1, - "value": "value_value", - "case_sensitive": True, - }, - "in_list_filter": { - "values": ["values_value1", "values_value2"], - "case_sensitive": True, - }, - "field_name": "field_name_value", - }, - }, - "data_collection_start_time": {"seconds": 751, "nanos": 543}, + request_init = {"parent": "properties/sample1"} + request_init["bigquery_link"] = { + "name": "name_value", + "project": "project_value", + "create_time": {"seconds": 751, "nanos": 543}, + "daily_export_enabled": True, + "streaming_export_enabled": True, + "fresh_daily_export_enabled": True, + "include_advertising_id": True, + "export_streams": ["export_streams_value1", "export_streams_value2"], + "excluded_events": ["excluded_events_value1", "excluded_events_value2"], + "dataset_location": "dataset_location_value", } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateExpandedDataSetRequest.meta.fields[ - "expanded_data_set" - ] + test_field = analytics_admin.CreateBigQueryLinkRequest.meta.fields["bigquery_link"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -108812,7 +114139,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["expanded_data_set"].items(): # pragma: NO COVER + for field, value in request_init["bigquery_link"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -108842,21 +114169,25 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["expanded_data_set"][field])): - del request_init["expanded_data_set"][field][i][subfield] + for i in range(0, len(request_init["bigquery_link"][field])): + del request_init["bigquery_link"][field][i][subfield] else: - del request_init["expanded_data_set"][field][subfield] + del request_init["bigquery_link"][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 = gaa_expanded_data_set.ExpandedDataSet( + return_value = resources.BigQueryLink( name="name_value", - display_name="display_name_value", - description="description_value", - dimension_names=["dimension_names_value"], - metric_names=["metric_names_value"], + project="project_value", + daily_export_enabled=True, + streaming_export_enabled=True, + fresh_daily_export_enabled=True, + include_advertising_id=True, + export_streams=["export_streams_value"], + excluded_events=["excluded_events_value"], + dataset_location="dataset_location_value", ) # Wrap the value into a proper Response obj @@ -108864,24 +114195,28 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_expanded_data_set.ExpandedDataSet.pb(return_value) + return_value = resources.BigQueryLink.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_expanded_data_set(request) + response = client.create_big_query_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_expanded_data_set.ExpandedDataSet) + assert isinstance(response, resources.BigQueryLink) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.dimension_names == ["dimension_names_value"] - assert response.metric_names == ["metric_names_value"] + assert response.project == "project_value" + assert response.daily_export_enabled is True + assert response.streaming_export_enabled is True + assert response.fresh_daily_export_enabled is True + assert response.include_advertising_id is True + assert response.export_streams == ["export_streams_value"] + assert response.excluded_events == ["excluded_events_value"] + assert response.dataset_location == "dataset_location_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_expanded_data_set_rest_interceptors(null_interceptor): +def test_create_big_query_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -108895,18 +114230,18 @@ def test_update_expanded_data_set_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_expanded_data_set" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_big_query_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_expanded_data_set_with_metadata", + "post_create_big_query_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_expanded_data_set" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_big_query_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateExpandedDataSetRequest.pb( - analytics_admin.UpdateExpandedDataSetRequest() + pb_message = analytics_admin.CreateBigQueryLinkRequest.pb( + analytics_admin.CreateBigQueryLinkRequest() ) transcode.return_value = { "method": "post", @@ -108918,24 +114253,19 @@ def test_update_expanded_data_set_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 = gaa_expanded_data_set.ExpandedDataSet.to_json( - gaa_expanded_data_set.ExpandedDataSet() - ) + return_value = resources.BigQueryLink.to_json(resources.BigQueryLink()) req.return_value.content = return_value - request = analytics_admin.UpdateExpandedDataSetRequest() + request = analytics_admin.CreateBigQueryLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_expanded_data_set.ExpandedDataSet() - post_with_metadata.return_value = ( - gaa_expanded_data_set.ExpandedDataSet(), - metadata, - ) + post.return_value = resources.BigQueryLink() + post_with_metadata.return_value = resources.BigQueryLink(), metadata - client.update_expanded_data_set( + client.create_big_query_link( request, metadata=[ ("key", "val"), @@ -108948,123 +114278,14 @@ def test_update_expanded_data_set_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_expanded_data_set_rest_bad_request( - request_type=analytics_admin.DeleteExpandedDataSetRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/expandedDataSets/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.delete_expanded_data_set(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.DeleteExpandedDataSetRequest, - dict, - ], -) -def test_delete_expanded_data_set_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/expandedDataSets/sample2"} - request = request_type(**request_init) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = None - - # Wrap the value into a proper Response obj - response_value = 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_expanded_data_set(request) - - # Establish that the response is the type that we expect. - assert response is None - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_expanded_data_set_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "pre_delete_expanded_data_set" - ) as pre: - pre.assert_not_called() - pb_message = analytics_admin.DeleteExpandedDataSetRequest.pb( - analytics_admin.DeleteExpandedDataSetRequest() - ) - 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"} - - request = analytics_admin.DeleteExpandedDataSetRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - - client.delete_expanded_data_set( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - - -def test_get_channel_group_rest_bad_request( - request_type=analytics_admin.GetChannelGroupRequest, +def test_get_big_query_link_rest_bad_request( + request_type=analytics_admin.GetBigQueryLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/channelGroups/sample2"} + request_init = {"name": "properties/sample1/bigQueryLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -109079,34 +114300,38 @@ def test_get_channel_group_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_channel_group(request) + client.get_big_query_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetChannelGroupRequest, + analytics_admin.GetBigQueryLinkRequest, dict, ], ) -def test_get_channel_group_rest_call_success(request_type): +def test_get_big_query_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/channelGroups/sample2"} + request_init = {"name": "properties/sample1/bigQueryLinks/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 = channel_group.ChannelGroup( + return_value = resources.BigQueryLink( name="name_value", - display_name="display_name_value", - description="description_value", - system_defined=True, - primary=True, + project="project_value", + daily_export_enabled=True, + streaming_export_enabled=True, + fresh_daily_export_enabled=True, + include_advertising_id=True, + export_streams=["export_streams_value"], + excluded_events=["excluded_events_value"], + dataset_location="dataset_location_value", ) # Wrap the value into a proper Response obj @@ -109114,24 +114339,28 @@ def test_get_channel_group_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = channel_group.ChannelGroup.pb(return_value) + return_value = resources.BigQueryLink.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_channel_group(request) + response = client.get_big_query_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, channel_group.ChannelGroup) + assert isinstance(response, resources.BigQueryLink) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.system_defined is True - assert response.primary is True + assert response.project == "project_value" + assert response.daily_export_enabled is True + assert response.streaming_export_enabled is True + assert response.fresh_daily_export_enabled is True + assert response.include_advertising_id is True + assert response.export_streams == ["export_streams_value"] + assert response.excluded_events == ["excluded_events_value"] + assert response.dataset_location == "dataset_location_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_channel_group_rest_interceptors(null_interceptor): +def test_get_big_query_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -109145,18 +114374,18 @@ def test_get_channel_group_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_channel_group" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_big_query_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_channel_group_with_metadata", + "post_get_big_query_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_channel_group" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_big_query_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetChannelGroupRequest.pb( - analytics_admin.GetChannelGroupRequest() + pb_message = analytics_admin.GetBigQueryLinkRequest.pb( + analytics_admin.GetBigQueryLinkRequest() ) transcode.return_value = { "method": "post", @@ -109168,19 +114397,19 @@ def test_get_channel_group_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 = channel_group.ChannelGroup.to_json(channel_group.ChannelGroup()) + return_value = resources.BigQueryLink.to_json(resources.BigQueryLink()) req.return_value.content = return_value - request = analytics_admin.GetChannelGroupRequest() + request = analytics_admin.GetBigQueryLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = channel_group.ChannelGroup() - post_with_metadata.return_value = channel_group.ChannelGroup(), metadata + post.return_value = resources.BigQueryLink() + post_with_metadata.return_value = resources.BigQueryLink(), metadata - client.get_channel_group( + client.get_big_query_link( request, metadata=[ ("key", "val"), @@ -109193,8 +114422,8 @@ def test_get_channel_group_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_channel_groups_rest_bad_request( - request_type=analytics_admin.ListChannelGroupsRequest, +def test_list_big_query_links_rest_bad_request( + request_type=analytics_admin.ListBigQueryLinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -109215,17 +114444,17 @@ def test_list_channel_groups_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.list_channel_groups(request) + client.list_big_query_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListChannelGroupsRequest, + analytics_admin.ListBigQueryLinksRequest, dict, ], ) -def test_list_channel_groups_rest_call_success(request_type): +def test_list_big_query_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -109237,7 +114466,7 @@ def test_list_channel_groups_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListChannelGroupsResponse( + return_value = analytics_admin.ListBigQueryLinksResponse( next_page_token="next_page_token_value", ) @@ -109246,20 +114475,20 @@ def test_list_channel_groups_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListChannelGroupsResponse.pb(return_value) + return_value = analytics_admin.ListBigQueryLinksResponse.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_channel_groups(request) + response = client.list_big_query_links(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListChannelGroupsPager) + assert isinstance(response, pagers.ListBigQueryLinksPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_channel_groups_rest_interceptors(null_interceptor): +def test_list_big_query_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -109273,18 +114502,18 @@ def test_list_channel_groups_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_channel_groups" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_big_query_links" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_channel_groups_with_metadata", + "post_list_big_query_links_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_channel_groups" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_big_query_links" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListChannelGroupsRequest.pb( - analytics_admin.ListChannelGroupsRequest() + pb_message = analytics_admin.ListBigQueryLinksRequest.pb( + analytics_admin.ListBigQueryLinksRequest() ) transcode.return_value = { "method": "post", @@ -109296,24 +114525,24 @@ def test_list_channel_groups_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 = analytics_admin.ListChannelGroupsResponse.to_json( - analytics_admin.ListChannelGroupsResponse() + return_value = analytics_admin.ListBigQueryLinksResponse.to_json( + analytics_admin.ListBigQueryLinksResponse() ) req.return_value.content = return_value - request = analytics_admin.ListChannelGroupsRequest() + request = analytics_admin.ListBigQueryLinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListChannelGroupsResponse() + post.return_value = analytics_admin.ListBigQueryLinksResponse() post_with_metadata.return_value = ( - analytics_admin.ListChannelGroupsResponse(), + analytics_admin.ListBigQueryLinksResponse(), metadata, ) - client.list_channel_groups( + client.list_big_query_links( request, metadata=[ ("key", "val"), @@ -109326,14 +114555,14 @@ def test_list_channel_groups_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_channel_group_rest_bad_request( - request_type=analytics_admin.CreateChannelGroupRequest, +def test_delete_big_query_link_rest_bad_request( + request_type=analytics_admin.DeleteBigQueryLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"name": "properties/sample1/bigQueryLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -109343,155 +114572,50 @@ def test_create_channel_group_rest_bad_request( # 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_channel_group(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.CreateChannelGroupRequest, - dict, - ], -) -def test_create_channel_group_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["channel_group"] = { - "name": "name_value", - "display_name": "display_name_value", - "description": "description_value", - "grouping_rule": [ - { - "display_name": "display_name_value", - "expression": { - "and_group": {"filter_expressions": {}}, - "or_group": {}, - "not_expression": {}, - "filter": { - "string_filter": {"match_type": 1, "value": "value_value"}, - "in_list_filter": { - "values": ["values_value1", "values_value2"] - }, - "field_name": "field_name_value", - }, - }, - } - ], - "system_defined": True, - "primary": True, - } - # 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 = analytics_admin.CreateChannelGroupRequest.meta.fields["channel_group"] - - 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["channel_group"].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 + 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_big_query_link(request) - if result and hasattr(result, "keys"): - for subfield in result.keys(): - if (field, subfield) not in runtime_nested_fields: - subfields_not_in_runtime.append( - { - "field": field, - "subfield": subfield, - "is_repeated": is_repeated, - } - ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["channel_group"][field])): - del request_init["channel_group"][field][i][subfield] - else: - del request_init["channel_group"][field][subfield] +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.DeleteBigQueryLinkRequest, + dict, + ], +) +def test_delete_big_query_link_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "properties/sample1/bigQueryLinks/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 = gaa_channel_group.ChannelGroup( - name="name_value", - display_name="display_name_value", - description="description_value", - system_defined=True, - primary=True, - ) + return_value = None # 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 = gaa_channel_group.ChannelGroup.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"} - response = client.create_channel_group(request) + response = client.delete_big_query_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_channel_group.ChannelGroup) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.system_defined is True - assert response.primary is True + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_channel_group_rest_interceptors(null_interceptor): +def test_delete_big_query_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -109505,18 +114629,11 @@ def test_create_channel_group_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_channel_group" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_channel_group_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_channel_group" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_big_query_link" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateChannelGroupRequest.pb( - analytics_admin.CreateChannelGroupRequest() + pb_message = analytics_admin.DeleteBigQueryLinkRequest.pb( + analytics_admin.DeleteBigQueryLinkRequest() ) transcode.return_value = { "method": "post", @@ -109528,21 +114645,15 @@ def test_create_channel_group_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 = gaa_channel_group.ChannelGroup.to_json( - gaa_channel_group.ChannelGroup() - ) - req.return_value.content = return_value - request = analytics_admin.CreateChannelGroupRequest() + request = analytics_admin.DeleteBigQueryLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_channel_group.ChannelGroup() - post_with_metadata.return_value = gaa_channel_group.ChannelGroup(), metadata - client.create_channel_group( + client.delete_big_query_link( request, metadata=[ ("key", "val"), @@ -109551,19 +114662,17 @@ def test_create_channel_group_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_update_channel_group_rest_bad_request( - request_type=analytics_admin.UpdateChannelGroupRequest, +def test_update_big_query_link_rest_bad_request( + request_type=analytics_admin.UpdateBigQueryLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "channel_group": {"name": "properties/sample1/channelGroups/sample2"} + "bigquery_link": {"name": "properties/sample1/bigQueryLinks/sample2"} } request = request_type(**request_init) @@ -109579,55 +114688,43 @@ def test_update_channel_group_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_channel_group(request) + client.update_big_query_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateChannelGroupRequest, + analytics_admin.UpdateBigQueryLinkRequest, dict, ], ) -def test_update_channel_group_rest_call_success(request_type): +def test_update_big_query_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "channel_group": {"name": "properties/sample1/channelGroups/sample2"} + "bigquery_link": {"name": "properties/sample1/bigQueryLinks/sample2"} } - request_init["channel_group"] = { - "name": "properties/sample1/channelGroups/sample2", - "display_name": "display_name_value", - "description": "description_value", - "grouping_rule": [ - { - "display_name": "display_name_value", - "expression": { - "and_group": {"filter_expressions": {}}, - "or_group": {}, - "not_expression": {}, - "filter": { - "string_filter": {"match_type": 1, "value": "value_value"}, - "in_list_filter": { - "values": ["values_value1", "values_value2"] - }, - "field_name": "field_name_value", - }, - }, - } - ], - "system_defined": True, - "primary": True, + request_init["bigquery_link"] = { + "name": "properties/sample1/bigQueryLinks/sample2", + "project": "project_value", + "create_time": {"seconds": 751, "nanos": 543}, + "daily_export_enabled": True, + "streaming_export_enabled": True, + "fresh_daily_export_enabled": True, + "include_advertising_id": True, + "export_streams": ["export_streams_value1", "export_streams_value2"], + "excluded_events": ["excluded_events_value1", "excluded_events_value2"], + "dataset_location": "dataset_location_value", } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateChannelGroupRequest.meta.fields["channel_group"] + test_field = analytics_admin.UpdateBigQueryLinkRequest.meta.fields["bigquery_link"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -109655,7 +114752,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["channel_group"].items(): # pragma: NO COVER + for field, value in request_init["bigquery_link"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -109685,21 +114782,25 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["channel_group"][field])): - del request_init["channel_group"][field][i][subfield] + for i in range(0, len(request_init["bigquery_link"][field])): + del request_init["bigquery_link"][field][i][subfield] else: - del request_init["channel_group"][field][subfield] + del request_init["bigquery_link"][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 = gaa_channel_group.ChannelGroup( + return_value = resources.BigQueryLink( name="name_value", - display_name="display_name_value", - description="description_value", - system_defined=True, - primary=True, + project="project_value", + daily_export_enabled=True, + streaming_export_enabled=True, + fresh_daily_export_enabled=True, + include_advertising_id=True, + export_streams=["export_streams_value"], + excluded_events=["excluded_events_value"], + dataset_location="dataset_location_value", ) # Wrap the value into a proper Response obj @@ -109707,24 +114808,28 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_channel_group.ChannelGroup.pb(return_value) + return_value = resources.BigQueryLink.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_channel_group(request) + response = client.update_big_query_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_channel_group.ChannelGroup) + assert isinstance(response, resources.BigQueryLink) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.description == "description_value" - assert response.system_defined is True - assert response.primary is True + assert response.project == "project_value" + assert response.daily_export_enabled is True + assert response.streaming_export_enabled is True + assert response.fresh_daily_export_enabled is True + assert response.include_advertising_id is True + assert response.export_streams == ["export_streams_value"] + assert response.excluded_events == ["excluded_events_value"] + assert response.dataset_location == "dataset_location_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_channel_group_rest_interceptors(null_interceptor): +def test_update_big_query_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -109738,18 +114843,18 @@ def test_update_channel_group_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_channel_group" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_big_query_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_channel_group_with_metadata", + "post_update_big_query_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_channel_group" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_big_query_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateChannelGroupRequest.pb( - analytics_admin.UpdateChannelGroupRequest() + pb_message = analytics_admin.UpdateBigQueryLinkRequest.pb( + analytics_admin.UpdateBigQueryLinkRequest() ) transcode.return_value = { "method": "post", @@ -109761,21 +114866,19 @@ def test_update_channel_group_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 = gaa_channel_group.ChannelGroup.to_json( - gaa_channel_group.ChannelGroup() - ) + return_value = resources.BigQueryLink.to_json(resources.BigQueryLink()) req.return_value.content = return_value - request = analytics_admin.UpdateChannelGroupRequest() + request = analytics_admin.UpdateBigQueryLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_channel_group.ChannelGroup() - post_with_metadata.return_value = gaa_channel_group.ChannelGroup(), metadata + post.return_value = resources.BigQueryLink() + post_with_metadata.return_value = resources.BigQueryLink(), metadata - client.update_channel_group( + client.update_big_query_link( request, metadata=[ ("key", "val"), @@ -109788,14 +114891,16 @@ def test_update_channel_group_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_channel_group_rest_bad_request( - request_type=analytics_admin.DeleteChannelGroupRequest, +def test_get_enhanced_measurement_settings_rest_bad_request( + request_type=analytics_admin.GetEnhancedMeasurementSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/channelGroups/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -109810,45 +114915,73 @@ def test_delete_channel_group_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_channel_group(request) + client.get_enhanced_measurement_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteChannelGroupRequest, + analytics_admin.GetEnhancedMeasurementSettingsRequest, dict, ], ) -def test_delete_channel_group_rest_call_success(request_type): +def test_get_enhanced_measurement_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/channelGroups/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.EnhancedMeasurementSettings( + name="name_value", + stream_enabled=True, + scrolls_enabled=True, + outbound_clicks_enabled=True, + site_search_enabled=True, + video_engagement_enabled=True, + file_downloads_enabled=True, + page_changes_enabled=True, + form_interactions_enabled=True, + search_query_parameter="search_query_parameter_value", + uri_query_parameter="uri_query_parameter_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.EnhancedMeasurementSettings.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_channel_group(request) + response = client.get_enhanced_measurement_settings(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.EnhancedMeasurementSettings) + assert response.name == "name_value" + assert response.stream_enabled is True + assert response.scrolls_enabled is True + assert response.outbound_clicks_enabled is True + assert response.site_search_enabled is True + assert response.video_engagement_enabled is True + assert response.file_downloads_enabled is True + assert response.page_changes_enabled is True + assert response.form_interactions_enabled is True + assert response.search_query_parameter == "search_query_parameter_value" + assert response.uri_query_parameter == "uri_query_parameter_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_channel_group_rest_interceptors(null_interceptor): +def test_get_enhanced_measurement_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -109862,11 +114995,20 @@ def test_delete_channel_group_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_channel_group" + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_enhanced_measurement_settings", + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_enhanced_measurement_settings_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "pre_get_enhanced_measurement_settings", ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteChannelGroupRequest.pb( - analytics_admin.DeleteChannelGroupRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetEnhancedMeasurementSettingsRequest.pb( + analytics_admin.GetEnhancedMeasurementSettingsRequest() ) transcode.return_value = { "method": "post", @@ -109878,15 +115020,24 @@ def test_delete_channel_group_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.EnhancedMeasurementSettings.to_json( + resources.EnhancedMeasurementSettings() + ) + req.return_value.content = return_value - request = analytics_admin.DeleteChannelGroupRequest() + request = analytics_admin.GetEnhancedMeasurementSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.EnhancedMeasurementSettings() + post_with_metadata.return_value = ( + resources.EnhancedMeasurementSettings(), + metadata, + ) - client.delete_channel_group( + client.get_enhanced_measurement_settings( request, metadata=[ ("key", "val"), @@ -109895,16 +115046,22 @@ def test_delete_channel_group_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_set_automated_ga4_configuration_opt_out_rest_bad_request( - request_type=analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, +def test_update_enhanced_measurement_settings_rest_bad_request( + request_type=analytics_admin.UpdateEnhancedMeasurementSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "enhanced_measurement_settings": { + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -109919,52 +115076,163 @@ def test_set_automated_ga4_configuration_opt_out_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.set_automated_ga4_configuration_opt_out(request) + client.update_enhanced_measurement_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest, + analytics_admin.UpdateEnhancedMeasurementSettingsRequest, dict, ], ) -def test_set_automated_ga4_configuration_opt_out_rest_call_success(request_type): +def test_update_enhanced_measurement_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "enhanced_measurement_settings": { + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" + } + } + request_init["enhanced_measurement_settings"] = { + "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings", + "stream_enabled": True, + "scrolls_enabled": True, + "outbound_clicks_enabled": True, + "site_search_enabled": True, + "video_engagement_enabled": True, + "file_downloads_enabled": True, + "page_changes_enabled": True, + "form_interactions_enabled": True, + "search_query_parameter": "search_query_parameter_value", + "uri_query_parameter": "uri_query_parameter_value", + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateEnhancedMeasurementSettingsRequest.meta.fields[ + "enhanced_measurement_settings" + ] + + 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[ + "enhanced_measurement_settings" + ].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["enhanced_measurement_settings"][field]) + ): + del request_init["enhanced_measurement_settings"][field][i][ + subfield + ] + else: + del request_init["enhanced_measurement_settings"][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 = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + return_value = resources.EnhancedMeasurementSettings( + name="name_value", + stream_enabled=True, + scrolls_enabled=True, + outbound_clicks_enabled=True, + site_search_enabled=True, + video_engagement_enabled=True, + file_downloads_enabled=True, + page_changes_enabled=True, + form_interactions_enabled=True, + search_query_parameter="search_query_parameter_value", + uri_query_parameter="uri_query_parameter_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 = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.pb( - return_value - ) + return_value = resources.EnhancedMeasurementSettings.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.set_automated_ga4_configuration_opt_out(request) + response = client.update_enhanced_measurement_settings(request) # Establish that the response is the type that we expect. - assert isinstance( - response, analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse - ) + assert isinstance(response, resources.EnhancedMeasurementSettings) + assert response.name == "name_value" + assert response.stream_enabled is True + assert response.scrolls_enabled is True + assert response.outbound_clicks_enabled is True + assert response.site_search_enabled is True + assert response.video_engagement_enabled is True + assert response.file_downloads_enabled is True + assert response.page_changes_enabled is True + assert response.form_interactions_enabled is True + assert response.search_query_parameter == "search_query_parameter_value" + assert response.uri_query_parameter == "uri_query_parameter_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_set_automated_ga4_configuration_opt_out_rest_interceptors(null_interceptor): +def test_update_enhanced_measurement_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -109979,19 +115247,19 @@ def test_set_automated_ga4_configuration_opt_out_rest_interceptors(null_intercep path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_set_automated_ga4_configuration_opt_out", + "post_update_enhanced_measurement_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_set_automated_ga4_configuration_opt_out_with_metadata", + "post_update_enhanced_measurement_settings_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_set_automated_ga4_configuration_opt_out", + "pre_update_enhanced_measurement_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest.pb( - analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() + pb_message = analytics_admin.UpdateEnhancedMeasurementSettingsRequest.pb( + analytics_admin.UpdateEnhancedMeasurementSettingsRequest() ) transcode.return_value = { "method": "post", @@ -110003,26 +115271,24 @@ def test_set_automated_ga4_configuration_opt_out_rest_interceptors(null_intercep 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 = ( - analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse.to_json( - analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() - ) + return_value = resources.EnhancedMeasurementSettings.to_json( + resources.EnhancedMeasurementSettings() ) req.return_value.content = return_value - request = analytics_admin.SetAutomatedGa4ConfigurationOptOutRequest() + request = analytics_admin.UpdateEnhancedMeasurementSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse() + post.return_value = resources.EnhancedMeasurementSettings() post_with_metadata.return_value = ( - analytics_admin.SetAutomatedGa4ConfigurationOptOutResponse(), + resources.EnhancedMeasurementSettings(), metadata, ) - client.set_automated_ga4_configuration_opt_out( + client.update_enhanced_measurement_settings( request, metadata=[ ("key", "val"), @@ -110035,8 +115301,8 @@ def test_set_automated_ga4_configuration_opt_out_rest_interceptors(null_intercep post_with_metadata.assert_called_once() -def test_fetch_automated_ga4_configuration_opt_out_rest_bad_request( - request_type=analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest, +def test_create_connected_site_tag_rest_bad_request( + request_type=analytics_admin.CreateConnectedSiteTagRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -110057,17 +115323,17 @@ def test_fetch_automated_ga4_configuration_opt_out_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.fetch_automated_ga4_configuration_opt_out(request) + client.create_connected_site_tag(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest, + analytics_admin.CreateConnectedSiteTagRequest, dict, ], ) -def test_fetch_automated_ga4_configuration_opt_out_rest_call_success(request_type): +def test_create_connected_site_tag_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -110079,33 +115345,26 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_call_success(request_typ # 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 = analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse( - opt_out=True, - ) + return_value = analytics_admin.CreateConnectedSiteTagResponse() # 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 = analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse.pb( - return_value - ) + return_value = analytics_admin.CreateConnectedSiteTagResponse.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_automated_ga4_configuration_opt_out(request) + response = client.create_connected_site_tag(request) # Establish that the response is the type that we expect. - assert isinstance( - response, analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse - ) - assert response.opt_out is True + assert isinstance(response, analytics_admin.CreateConnectedSiteTagResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_fetch_automated_ga4_configuration_opt_out_rest_interceptors(null_interceptor): +def test_create_connected_site_tag_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -110120,19 +115379,18 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_interceptors(null_interc path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_fetch_automated_ga4_configuration_opt_out", + "post_create_connected_site_tag", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_fetch_automated_ga4_configuration_opt_out_with_metadata", + "post_create_connected_site_tag_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_fetch_automated_ga4_configuration_opt_out", + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_connected_site_tag" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest.pb( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() + pb_message = analytics_admin.CreateConnectedSiteTagRequest.pb( + analytics_admin.CreateConnectedSiteTagRequest() ) transcode.return_value = { "method": "post", @@ -110144,28 +115402,24 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_interceptors(null_interc 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 = ( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse.to_json( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() - ) + return_value = analytics_admin.CreateConnectedSiteTagResponse.to_json( + analytics_admin.CreateConnectedSiteTagResponse() ) req.return_value.content = return_value - request = analytics_admin.FetchAutomatedGa4ConfigurationOptOutRequest() + request = analytics_admin.CreateConnectedSiteTagRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = ( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse() - ) + post.return_value = analytics_admin.CreateConnectedSiteTagResponse() post_with_metadata.return_value = ( - analytics_admin.FetchAutomatedGa4ConfigurationOptOutResponse(), + analytics_admin.CreateConnectedSiteTagResponse(), metadata, ) - client.fetch_automated_ga4_configuration_opt_out( + client.create_connected_site_tag( request, metadata=[ ("key", "val"), @@ -110178,14 +115432,14 @@ def test_fetch_automated_ga4_configuration_opt_out_rest_interceptors(null_interc post_with_metadata.assert_called_once() -def test_create_big_query_link_rest_bad_request( - request_type=analytics_admin.CreateBigQueryLinkRequest, +def test_delete_connected_site_tag_rest_bad_request( + request_type=analytics_admin.DeleteConnectedSiteTagRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -110200,146 +115454,45 @@ def test_create_big_query_link_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_big_query_link(request) + client.delete_connected_site_tag(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateBigQueryLinkRequest, + analytics_admin.DeleteConnectedSiteTagRequest, dict, ], ) -def test_create_big_query_link_rest_call_success(request_type): +def test_delete_connected_site_tag_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["bigquery_link"] = { - "name": "name_value", - "project": "project_value", - "create_time": {"seconds": 751, "nanos": 543}, - "daily_export_enabled": True, - "streaming_export_enabled": True, - "fresh_daily_export_enabled": True, - "include_advertising_id": True, - "export_streams": ["export_streams_value1", "export_streams_value2"], - "excluded_events": ["excluded_events_value1", "excluded_events_value2"], - "dataset_location": "dataset_location_value", - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateBigQueryLinkRequest.meta.fields["bigquery_link"] - - 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["bigquery_link"].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["bigquery_link"][field])): - del request_init["bigquery_link"][field][i][subfield] - else: - del request_init["bigquery_link"][field][subfield] + 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 = resources.BigQueryLink( - name="name_value", - project="project_value", - daily_export_enabled=True, - streaming_export_enabled=True, - fresh_daily_export_enabled=True, - include_advertising_id=True, - export_streams=["export_streams_value"], - excluded_events=["excluded_events_value"], - dataset_location="dataset_location_value", - ) + return_value = None # 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.BigQueryLink.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"} - response = client.create_big_query_link(request) + response = client.delete_connected_site_tag(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.BigQueryLink) - assert response.name == "name_value" - assert response.project == "project_value" - assert response.daily_export_enabled is True - assert response.streaming_export_enabled is True - assert response.fresh_daily_export_enabled is True - assert response.include_advertising_id is True - assert response.export_streams == ["export_streams_value"] - assert response.excluded_events == ["excluded_events_value"] - assert response.dataset_location == "dataset_location_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_big_query_link_rest_interceptors(null_interceptor): +def test_delete_connected_site_tag_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -110353,18 +115506,11 @@ def test_create_big_query_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_big_query_link" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_big_query_link_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_big_query_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_connected_site_tag" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateBigQueryLinkRequest.pb( - analytics_admin.CreateBigQueryLinkRequest() + pb_message = analytics_admin.DeleteConnectedSiteTagRequest.pb( + analytics_admin.DeleteConnectedSiteTagRequest() ) transcode.return_value = { "method": "post", @@ -110376,19 +115522,15 @@ def test_create_big_query_link_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.BigQueryLink.to_json(resources.BigQueryLink()) - req.return_value.content = return_value - request = analytics_admin.CreateBigQueryLinkRequest() + request = analytics_admin.DeleteConnectedSiteTagRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.BigQueryLink() - post_with_metadata.return_value = resources.BigQueryLink(), metadata - client.create_big_query_link( + client.delete_connected_site_tag( request, metadata=[ ("key", "val"), @@ -110397,18 +115539,16 @@ def test_create_big_query_link_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_get_big_query_link_rest_bad_request( - request_type=analytics_admin.GetBigQueryLinkRequest, +def test_list_connected_site_tags_rest_bad_request( + request_type=analytics_admin.ListConnectedSiteTagsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/bigQueryLinks/sample2"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -110423,67 +115563,48 @@ def test_get_big_query_link_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_big_query_link(request) + client.list_connected_site_tags(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetBigQueryLinkRequest, + analytics_admin.ListConnectedSiteTagsRequest, dict, ], ) -def test_get_big_query_link_rest_call_success(request_type): +def test_list_connected_site_tags_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/bigQueryLinks/sample2"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = resources.BigQueryLink( - name="name_value", - project="project_value", - daily_export_enabled=True, - streaming_export_enabled=True, - fresh_daily_export_enabled=True, - include_advertising_id=True, - export_streams=["export_streams_value"], - excluded_events=["excluded_events_value"], - dataset_location="dataset_location_value", - ) + return_value = analytics_admin.ListConnectedSiteTagsResponse() # 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.BigQueryLink.pb(return_value) + return_value = analytics_admin.ListConnectedSiteTagsResponse.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_big_query_link(request) + response = client.list_connected_site_tags(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.BigQueryLink) - assert response.name == "name_value" - assert response.project == "project_value" - assert response.daily_export_enabled is True - assert response.streaming_export_enabled is True - assert response.fresh_daily_export_enabled is True - assert response.include_advertising_id is True - assert response.export_streams == ["export_streams_value"] - assert response.excluded_events == ["excluded_events_value"] - assert response.dataset_location == "dataset_location_value" + assert isinstance(response, analytics_admin.ListConnectedSiteTagsResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_big_query_link_rest_interceptors(null_interceptor): +def test_list_connected_site_tags_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -110497,18 +115618,18 @@ def test_get_big_query_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_big_query_link" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_connected_site_tags" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_big_query_link_with_metadata", + "post_list_connected_site_tags_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_big_query_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_connected_site_tags" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetBigQueryLinkRequest.pb( - analytics_admin.GetBigQueryLinkRequest() + pb_message = analytics_admin.ListConnectedSiteTagsRequest.pb( + analytics_admin.ListConnectedSiteTagsRequest() ) transcode.return_value = { "method": "post", @@ -110520,19 +115641,24 @@ def test_get_big_query_link_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.BigQueryLink.to_json(resources.BigQueryLink()) + return_value = analytics_admin.ListConnectedSiteTagsResponse.to_json( + analytics_admin.ListConnectedSiteTagsResponse() + ) req.return_value.content = return_value - request = analytics_admin.GetBigQueryLinkRequest() + request = analytics_admin.ListConnectedSiteTagsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.BigQueryLink() - post_with_metadata.return_value = resources.BigQueryLink(), metadata + post.return_value = analytics_admin.ListConnectedSiteTagsResponse() + post_with_metadata.return_value = ( + analytics_admin.ListConnectedSiteTagsResponse(), + metadata, + ) - client.get_big_query_link( + client.list_connected_site_tags( request, metadata=[ ("key", "val"), @@ -110545,14 +115671,14 @@ def test_get_big_query_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_big_query_links_rest_bad_request( - request_type=analytics_admin.ListBigQueryLinksRequest, +def test_fetch_connected_ga4_property_rest_bad_request( + request_type=analytics_admin.FetchConnectedGa4PropertyRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -110567,30 +115693,30 @@ def test_list_big_query_links_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.list_big_query_links(request) + client.fetch_connected_ga4_property(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListBigQueryLinksRequest, + analytics_admin.FetchConnectedGa4PropertyRequest, dict, ], ) -def test_list_big_query_links_rest_call_success(request_type): +def test_fetch_connected_ga4_property_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListBigQueryLinksResponse( - next_page_token="next_page_token_value", + return_value = analytics_admin.FetchConnectedGa4PropertyResponse( + property="property_value", ) # Wrap the value into a proper Response obj @@ -110598,20 +115724,22 @@ def test_list_big_query_links_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListBigQueryLinksResponse.pb(return_value) + return_value = analytics_admin.FetchConnectedGa4PropertyResponse.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_big_query_links(request) + response = client.fetch_connected_ga4_property(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListBigQueryLinksPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, analytics_admin.FetchConnectedGa4PropertyResponse) + assert response.property == "property_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_big_query_links_rest_interceptors(null_interceptor): +def test_fetch_connected_ga4_property_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -110625,18 +115753,20 @@ def test_list_big_query_links_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_big_query_links" + transports.AnalyticsAdminServiceRestInterceptor, + "post_fetch_connected_ga4_property", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_big_query_links_with_metadata", + "post_fetch_connected_ga4_property_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_big_query_links" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_fetch_connected_ga4_property", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListBigQueryLinksRequest.pb( - analytics_admin.ListBigQueryLinksRequest() + pb_message = analytics_admin.FetchConnectedGa4PropertyRequest.pb( + analytics_admin.FetchConnectedGa4PropertyRequest() ) transcode.return_value = { "method": "post", @@ -110648,24 +115778,24 @@ def test_list_big_query_links_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 = analytics_admin.ListBigQueryLinksResponse.to_json( - analytics_admin.ListBigQueryLinksResponse() + return_value = analytics_admin.FetchConnectedGa4PropertyResponse.to_json( + analytics_admin.FetchConnectedGa4PropertyResponse() ) req.return_value.content = return_value - request = analytics_admin.ListBigQueryLinksRequest() + request = analytics_admin.FetchConnectedGa4PropertyRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListBigQueryLinksResponse() + post.return_value = analytics_admin.FetchConnectedGa4PropertyResponse() post_with_metadata.return_value = ( - analytics_admin.ListBigQueryLinksResponse(), + analytics_admin.FetchConnectedGa4PropertyResponse(), metadata, ) - client.list_big_query_links( + client.fetch_connected_ga4_property( request, metadata=[ ("key", "val"), @@ -110678,14 +115808,14 @@ def test_list_big_query_links_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_big_query_link_rest_bad_request( - request_type=analytics_admin.DeleteBigQueryLinkRequest, +def test_get_ad_sense_link_rest_bad_request( + request_type=analytics_admin.GetAdSenseLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/bigQueryLinks/sample2"} + request_init = {"name": "properties/sample1/adSenseLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -110700,45 +115830,53 @@ def test_delete_big_query_link_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_big_query_link(request) + client.get_ad_sense_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteBigQueryLinkRequest, + analytics_admin.GetAdSenseLinkRequest, dict, ], ) -def test_delete_big_query_link_rest_call_success(request_type): +def test_get_ad_sense_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/bigQueryLinks/sample2"} + request_init = {"name": "properties/sample1/adSenseLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.AdSenseLink( + name="name_value", + ad_client_code="ad_client_code_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.AdSenseLink.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_big_query_link(request) + response = client.get_ad_sense_link(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.AdSenseLink) + assert response.name == "name_value" + assert response.ad_client_code == "ad_client_code_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_big_query_link_rest_interceptors(null_interceptor): +def test_get_ad_sense_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -110752,11 +115890,18 @@ def test_delete_big_query_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_big_query_link" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_ad_sense_link" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_ad_sense_link_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_ad_sense_link" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteBigQueryLinkRequest.pb( - analytics_admin.DeleteBigQueryLinkRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.GetAdSenseLinkRequest.pb( + analytics_admin.GetAdSenseLinkRequest() ) transcode.return_value = { "method": "post", @@ -110768,15 +115913,19 @@ def test_delete_big_query_link_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.AdSenseLink.to_json(resources.AdSenseLink()) + req.return_value.content = return_value - request = analytics_admin.DeleteBigQueryLinkRequest() + request = analytics_admin.GetAdSenseLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.AdSenseLink() + post_with_metadata.return_value = resources.AdSenseLink(), metadata - client.delete_big_query_link( + client.get_ad_sense_link( request, metadata=[ ("key", "val"), @@ -110785,18 +115934,18 @@ def test_delete_big_query_link_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_update_big_query_link_rest_bad_request( - request_type=analytics_admin.UpdateBigQueryLinkRequest, +def test_create_ad_sense_link_rest_bad_request( + request_type=analytics_admin.CreateAdSenseLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "bigquery_link": {"name": "properties/sample1/bigQueryLinks/sample2"} - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -110811,43 +115960,33 @@ def test_update_big_query_link_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_big_query_link(request) + client.create_ad_sense_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateBigQueryLinkRequest, + analytics_admin.CreateAdSenseLinkRequest, dict, ], ) -def test_update_big_query_link_rest_call_success(request_type): +def test_create_ad_sense_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "bigquery_link": {"name": "properties/sample1/bigQueryLinks/sample2"} - } - request_init["bigquery_link"] = { - "name": "properties/sample1/bigQueryLinks/sample2", - "project": "project_value", - "create_time": {"seconds": 751, "nanos": 543}, - "daily_export_enabled": True, - "streaming_export_enabled": True, - "fresh_daily_export_enabled": True, - "include_advertising_id": True, - "export_streams": ["export_streams_value1", "export_streams_value2"], - "excluded_events": ["excluded_events_value1", "excluded_events_value2"], - "dataset_location": "dataset_location_value", + request_init = {"parent": "properties/sample1"} + request_init["adsense_link"] = { + "name": "name_value", + "ad_client_code": "ad_client_code_value", } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateBigQueryLinkRequest.meta.fields["bigquery_link"] + test_field = analytics_admin.CreateAdSenseLinkRequest.meta.fields["adsense_link"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -110875,7 +116014,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["bigquery_link"].items(): # pragma: NO COVER + for field, value in request_init["adsense_link"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -110905,25 +116044,18 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["bigquery_link"][field])): - del request_init["bigquery_link"][field][i][subfield] + for i in range(0, len(request_init["adsense_link"][field])): + del request_init["adsense_link"][field][i][subfield] else: - del request_init["bigquery_link"][field][subfield] + del request_init["adsense_link"][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 = resources.BigQueryLink( + return_value = resources.AdSenseLink( name="name_value", - project="project_value", - daily_export_enabled=True, - streaming_export_enabled=True, - fresh_daily_export_enabled=True, - include_advertising_id=True, - export_streams=["export_streams_value"], - excluded_events=["excluded_events_value"], - dataset_location="dataset_location_value", + ad_client_code="ad_client_code_value", ) # Wrap the value into a proper Response obj @@ -110931,28 +116063,21 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.BigQueryLink.pb(return_value) + return_value = resources.AdSenseLink.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_big_query_link(request) + response = client.create_ad_sense_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.BigQueryLink) + assert isinstance(response, resources.AdSenseLink) assert response.name == "name_value" - assert response.project == "project_value" - assert response.daily_export_enabled is True - assert response.streaming_export_enabled is True - assert response.fresh_daily_export_enabled is True - assert response.include_advertising_id is True - assert response.export_streams == ["export_streams_value"] - assert response.excluded_events == ["excluded_events_value"] - assert response.dataset_location == "dataset_location_value" + assert response.ad_client_code == "ad_client_code_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_big_query_link_rest_interceptors(null_interceptor): +def test_create_ad_sense_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -110966,18 +116091,18 @@ def test_update_big_query_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_big_query_link" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_ad_sense_link" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_big_query_link_with_metadata", + "post_create_ad_sense_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_big_query_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_ad_sense_link" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateBigQueryLinkRequest.pb( - analytics_admin.UpdateBigQueryLinkRequest() + pb_message = analytics_admin.CreateAdSenseLinkRequest.pb( + analytics_admin.CreateAdSenseLinkRequest() ) transcode.return_value = { "method": "post", @@ -110989,19 +116114,19 @@ def test_update_big_query_link_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.BigQueryLink.to_json(resources.BigQueryLink()) + return_value = resources.AdSenseLink.to_json(resources.AdSenseLink()) req.return_value.content = return_value - request = analytics_admin.UpdateBigQueryLinkRequest() + request = analytics_admin.CreateAdSenseLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.BigQueryLink() - post_with_metadata.return_value = resources.BigQueryLink(), metadata + post.return_value = resources.AdSenseLink() + post_with_metadata.return_value = resources.AdSenseLink(), metadata - client.update_big_query_link( + client.create_ad_sense_link( request, metadata=[ ("key", "val"), @@ -111014,16 +116139,14 @@ def test_update_big_query_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_enhanced_measurement_settings_rest_bad_request( - request_type=analytics_admin.GetEnhancedMeasurementSettingsRequest, +def test_delete_ad_sense_link_rest_bad_request( + request_type=analytics_admin.DeleteAdSenseLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" - } + request_init = {"name": "properties/sample1/adSenseLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111038,73 +116161,45 @@ def test_get_enhanced_measurement_settings_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_enhanced_measurement_settings(request) + client.delete_ad_sense_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetEnhancedMeasurementSettingsRequest, + analytics_admin.DeleteAdSenseLinkRequest, dict, ], ) -def test_get_enhanced_measurement_settings_rest_call_success(request_type): +def test_delete_ad_sense_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" - } + request_init = {"name": "properties/sample1/adSenseLinks/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 = resources.EnhancedMeasurementSettings( - name="name_value", - stream_enabled=True, - scrolls_enabled=True, - outbound_clicks_enabled=True, - site_search_enabled=True, - video_engagement_enabled=True, - file_downloads_enabled=True, - page_changes_enabled=True, - form_interactions_enabled=True, - search_query_parameter="search_query_parameter_value", - uri_query_parameter="uri_query_parameter_value", - ) + return_value = None # 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.EnhancedMeasurementSettings.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"} - response = client.get_enhanced_measurement_settings(request) + response = client.delete_ad_sense_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.EnhancedMeasurementSettings) - assert response.name == "name_value" - assert response.stream_enabled is True - assert response.scrolls_enabled is True - assert response.outbound_clicks_enabled is True - assert response.site_search_enabled is True - assert response.video_engagement_enabled is True - assert response.file_downloads_enabled is True - assert response.page_changes_enabled is True - assert response.form_interactions_enabled is True - assert response.search_query_parameter == "search_query_parameter_value" - assert response.uri_query_parameter == "uri_query_parameter_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_enhanced_measurement_settings_rest_interceptors(null_interceptor): +def test_delete_ad_sense_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -111118,20 +116213,11 @@ def test_get_enhanced_measurement_settings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_enhanced_measurement_settings", - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_enhanced_measurement_settings_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_enhanced_measurement_settings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_ad_sense_link" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetEnhancedMeasurementSettingsRequest.pb( - analytics_admin.GetEnhancedMeasurementSettingsRequest() + pb_message = analytics_admin.DeleteAdSenseLinkRequest.pb( + analytics_admin.DeleteAdSenseLinkRequest() ) transcode.return_value = { "method": "post", @@ -111143,24 +116229,15 @@ def test_get_enhanced_measurement_settings_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.EnhancedMeasurementSettings.to_json( - resources.EnhancedMeasurementSettings() - ) - req.return_value.content = return_value - request = analytics_admin.GetEnhancedMeasurementSettingsRequest() + request = analytics_admin.DeleteAdSenseLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.EnhancedMeasurementSettings() - post_with_metadata.return_value = ( - resources.EnhancedMeasurementSettings(), - metadata, - ) - client.get_enhanced_measurement_settings( + client.delete_ad_sense_link( request, metadata=[ ("key", "val"), @@ -111169,22 +116246,16 @@ def test_get_enhanced_measurement_settings_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_update_enhanced_measurement_settings_rest_bad_request( - request_type=analytics_admin.UpdateEnhancedMeasurementSettingsRequest, +def test_list_ad_sense_links_rest_bad_request( + request_type=analytics_admin.ListAdSenseLinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "enhanced_measurement_settings": { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" - } - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111199,132 +116270,30 @@ def test_update_enhanced_measurement_settings_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_enhanced_measurement_settings(request) + client.list_ad_sense_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateEnhancedMeasurementSettingsRequest, + analytics_admin.ListAdSenseLinksRequest, dict, ], ) -def test_update_enhanced_measurement_settings_rest_call_success(request_type): +def test_list_ad_sense_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "enhanced_measurement_settings": { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings" - } - } - request_init["enhanced_measurement_settings"] = { - "name": "properties/sample1/dataStreams/sample2/enhancedMeasurementSettings", - "stream_enabled": True, - "scrolls_enabled": True, - "outbound_clicks_enabled": True, - "site_search_enabled": True, - "video_engagement_enabled": True, - "file_downloads_enabled": True, - "page_changes_enabled": True, - "form_interactions_enabled": True, - "search_query_parameter": "search_query_parameter_value", - "uri_query_parameter": "uri_query_parameter_value", - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.UpdateEnhancedMeasurementSettingsRequest.meta.fields[ - "enhanced_measurement_settings" - ] - - 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[ - "enhanced_measurement_settings" - ].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["enhanced_measurement_settings"][field]) - ): - del request_init["enhanced_measurement_settings"][field][i][ - subfield - ] - else: - del request_init["enhanced_measurement_settings"][field][subfield] + request_init = {"parent": "properties/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.EnhancedMeasurementSettings( - name="name_value", - stream_enabled=True, - scrolls_enabled=True, - outbound_clicks_enabled=True, - site_search_enabled=True, - video_engagement_enabled=True, - file_downloads_enabled=True, - page_changes_enabled=True, - form_interactions_enabled=True, - search_query_parameter="search_query_parameter_value", - uri_query_parameter="uri_query_parameter_value", + return_value = analytics_admin.ListAdSenseLinksResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -111332,30 +116301,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.EnhancedMeasurementSettings.pb(return_value) + return_value = analytics_admin.ListAdSenseLinksResponse.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_enhanced_measurement_settings(request) + response = client.list_ad_sense_links(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.EnhancedMeasurementSettings) - assert response.name == "name_value" - assert response.stream_enabled is True - assert response.scrolls_enabled is True - assert response.outbound_clicks_enabled is True - assert response.site_search_enabled is True - assert response.video_engagement_enabled is True - assert response.file_downloads_enabled is True - assert response.page_changes_enabled is True - assert response.form_interactions_enabled is True - assert response.search_query_parameter == "search_query_parameter_value" - assert response.uri_query_parameter == "uri_query_parameter_value" + assert isinstance(response, pagers.ListAdSenseLinksPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_enhanced_measurement_settings_rest_interceptors(null_interceptor): +def test_list_ad_sense_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -111369,20 +116328,18 @@ def test_update_enhanced_measurement_settings_rest_interceptors(null_interceptor ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_enhanced_measurement_settings", + transports.AnalyticsAdminServiceRestInterceptor, "post_list_ad_sense_links" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_enhanced_measurement_settings_with_metadata", + "post_list_ad_sense_links_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_enhanced_measurement_settings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_ad_sense_links" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateEnhancedMeasurementSettingsRequest.pb( - analytics_admin.UpdateEnhancedMeasurementSettingsRequest() + pb_message = analytics_admin.ListAdSenseLinksRequest.pb( + analytics_admin.ListAdSenseLinksRequest() ) transcode.return_value = { "method": "post", @@ -111394,24 +116351,24 @@ def test_update_enhanced_measurement_settings_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.EnhancedMeasurementSettings.to_json( - resources.EnhancedMeasurementSettings() + return_value = analytics_admin.ListAdSenseLinksResponse.to_json( + analytics_admin.ListAdSenseLinksResponse() ) req.return_value.content = return_value - request = analytics_admin.UpdateEnhancedMeasurementSettingsRequest() + request = analytics_admin.ListAdSenseLinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.EnhancedMeasurementSettings() + post.return_value = analytics_admin.ListAdSenseLinksResponse() post_with_metadata.return_value = ( - resources.EnhancedMeasurementSettings(), + analytics_admin.ListAdSenseLinksResponse(), metadata, ) - client.update_enhanced_measurement_settings( + client.list_ad_sense_links( request, metadata=[ ("key", "val"), @@ -111424,14 +116381,16 @@ def test_update_enhanced_measurement_settings_rest_interceptors(null_interceptor post_with_metadata.assert_called_once() -def test_create_connected_site_tag_rest_bad_request( - request_type=analytics_admin.CreateConnectedSiteTagRequest, +def test_get_event_create_rule_rest_bad_request( + request_type=analytics_admin.GetEventCreateRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111446,48 +116405,57 @@ def test_create_connected_site_tag_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_connected_site_tag(request) + client.get_event_create_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateConnectedSiteTagRequest, + analytics_admin.GetEventCreateRuleRequest, dict, ], ) -def test_create_connected_site_tag_rest_call_success(request_type): +def test_get_event_create_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/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 = analytics_admin.CreateConnectedSiteTagResponse() + return_value = event_create_and_edit.EventCreateRule( + name="name_value", + destination_event="destination_event_value", + source_copy_parameters=True, + ) # 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 = analytics_admin.CreateConnectedSiteTagResponse.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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.create_connected_site_tag(request) + response = client.get_event_create_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.CreateConnectedSiteTagResponse) + assert isinstance(response, event_create_and_edit.EventCreateRule) + assert response.name == "name_value" + assert response.destination_event == "destination_event_value" + assert response.source_copy_parameters is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_connected_site_tag_rest_interceptors(null_interceptor): +def test_get_event_create_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -111501,19 +116469,18 @@ def test_create_connected_site_tag_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_connected_site_tag", + transports.AnalyticsAdminServiceRestInterceptor, "post_get_event_create_rule" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_connected_site_tag_with_metadata", + "post_get_event_create_rule_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_connected_site_tag" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_event_create_rule" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateConnectedSiteTagRequest.pb( - analytics_admin.CreateConnectedSiteTagRequest() + pb_message = analytics_admin.GetEventCreateRuleRequest.pb( + analytics_admin.GetEventCreateRuleRequest() ) transcode.return_value = { "method": "post", @@ -111525,24 +116492,24 @@ def test_create_connected_site_tag_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 = analytics_admin.CreateConnectedSiteTagResponse.to_json( - analytics_admin.CreateConnectedSiteTagResponse() + return_value = event_create_and_edit.EventCreateRule.to_json( + event_create_and_edit.EventCreateRule() ) req.return_value.content = return_value - request = analytics_admin.CreateConnectedSiteTagRequest() + request = analytics_admin.GetEventCreateRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.CreateConnectedSiteTagResponse() + post.return_value = event_create_and_edit.EventCreateRule() post_with_metadata.return_value = ( - analytics_admin.CreateConnectedSiteTagResponse(), + event_create_and_edit.EventCreateRule(), metadata, ) - client.create_connected_site_tag( + client.get_event_create_rule( request, metadata=[ ("key", "val"), @@ -111555,14 +116522,14 @@ def test_create_connected_site_tag_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_connected_site_tag_rest_bad_request( - request_type=analytics_admin.DeleteConnectedSiteTagRequest, +def test_list_event_create_rules_rest_bad_request( + request_type=analytics_admin.ListEventCreateRulesRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111577,45 +116544,51 @@ def test_delete_connected_site_tag_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_connected_site_tag(request) + client.list_event_create_rules(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteConnectedSiteTagRequest, + analytics_admin.ListEventCreateRulesRequest, dict, ], ) -def test_delete_connected_site_tag_rest_call_success(request_type): +def test_list_event_create_rules_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.ListEventCreateRulesResponse( + next_page_token="next_page_token_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = analytics_admin.ListEventCreateRulesResponse.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_connected_site_tag(request) + response = client.list_event_create_rules(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, pagers.ListEventCreateRulesPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_connected_site_tag_rest_interceptors(null_interceptor): +def test_list_event_create_rules_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -111629,11 +116602,18 @@ def test_delete_connected_site_tag_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_connected_site_tag" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_event_create_rules" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_event_create_rules_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_event_create_rules" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteConnectedSiteTagRequest.pb( - analytics_admin.DeleteConnectedSiteTagRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ListEventCreateRulesRequest.pb( + analytics_admin.ListEventCreateRulesRequest() ) transcode.return_value = { "method": "post", @@ -111645,15 +116625,24 @@ def test_delete_connected_site_tag_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 = analytics_admin.ListEventCreateRulesResponse.to_json( + analytics_admin.ListEventCreateRulesResponse() + ) + req.return_value.content = return_value - request = analytics_admin.DeleteConnectedSiteTagRequest() + request = analytics_admin.ListEventCreateRulesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = analytics_admin.ListEventCreateRulesResponse() + post_with_metadata.return_value = ( + analytics_admin.ListEventCreateRulesResponse(), + metadata, + ) - client.delete_connected_site_tag( + client.list_event_create_rules( request, metadata=[ ("key", "val"), @@ -111662,16 +116651,18 @@ def test_delete_connected_site_tag_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_list_connected_site_tags_rest_bad_request( - request_type=analytics_admin.ListConnectedSiteTagsRequest, +def test_create_event_create_rule_rest_bad_request( + request_type=analytics_admin.CreateEventCreateRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111686,48 +116677,140 @@ def test_list_connected_site_tags_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.list_connected_site_tags(request) + client.create_event_create_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListConnectedSiteTagsRequest, + analytics_admin.CreateEventCreateRuleRequest, dict, ], ) -def test_list_connected_site_tags_rest_call_success(request_type): +def test_create_event_create_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init["event_create_rule"] = { + "name": "name_value", + "destination_event": "destination_event_value", + "event_conditions": [ + { + "field": "field_value", + "comparison_type": 1, + "value": "value_value", + "negated": True, + } + ], + "source_copy_parameters": True, + "parameter_mutations": [ + {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} + ], + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.CreateEventCreateRuleRequest.meta.fields[ + "event_create_rule" + ] + + 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["event_create_rule"].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["event_create_rule"][field])): + del request_init["event_create_rule"][field][i][subfield] + else: + del request_init["event_create_rule"][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 = analytics_admin.ListConnectedSiteTagsResponse() + return_value = event_create_and_edit.EventCreateRule( + name="name_value", + destination_event="destination_event_value", + source_copy_parameters=True, + ) # 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 = analytics_admin.ListConnectedSiteTagsResponse.pb(return_value) + return_value = event_create_and_edit.EventCreateRule.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_connected_site_tags(request) + response = client.create_event_create_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.ListConnectedSiteTagsResponse) + assert isinstance(response, event_create_and_edit.EventCreateRule) + assert response.name == "name_value" + assert response.destination_event == "destination_event_value" + assert response.source_copy_parameters is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_connected_site_tags_rest_interceptors(null_interceptor): +def test_create_event_create_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -111741,18 +116824,18 @@ def test_list_connected_site_tags_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_connected_site_tags" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_event_create_rule" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_connected_site_tags_with_metadata", + "post_create_event_create_rule_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_connected_site_tags" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_event_create_rule" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListConnectedSiteTagsRequest.pb( - analytics_admin.ListConnectedSiteTagsRequest() + pb_message = analytics_admin.CreateEventCreateRuleRequest.pb( + analytics_admin.CreateEventCreateRuleRequest() ) transcode.return_value = { "method": "post", @@ -111764,24 +116847,24 @@ def test_list_connected_site_tags_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 = analytics_admin.ListConnectedSiteTagsResponse.to_json( - analytics_admin.ListConnectedSiteTagsResponse() + return_value = event_create_and_edit.EventCreateRule.to_json( + event_create_and_edit.EventCreateRule() ) req.return_value.content = return_value - request = analytics_admin.ListConnectedSiteTagsRequest() + request = analytics_admin.CreateEventCreateRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListConnectedSiteTagsResponse() + post.return_value = event_create_and_edit.EventCreateRule() post_with_metadata.return_value = ( - analytics_admin.ListConnectedSiteTagsResponse(), + event_create_and_edit.EventCreateRule(), metadata, ) - client.list_connected_site_tags( + client.create_event_create_rule( request, metadata=[ ("key", "val"), @@ -111794,14 +116877,18 @@ def test_list_connected_site_tags_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_fetch_connected_ga4_property_rest_bad_request( - request_type=analytics_admin.FetchConnectedGa4PropertyRequest, +def test_update_event_create_rule_rest_bad_request( + request_type=analytics_admin.UpdateEventCreateRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "event_create_rule": { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111816,30 +116903,121 @@ def test_fetch_connected_ga4_property_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.fetch_connected_ga4_property(request) + client.update_event_create_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.FetchConnectedGa4PropertyRequest, + analytics_admin.UpdateEventCreateRuleRequest, dict, ], ) -def test_fetch_connected_ga4_property_rest_call_success(request_type): +def test_update_event_create_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = { + "event_create_rule": { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + } + } + request_init["event_create_rule"] = { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3", + "destination_event": "destination_event_value", + "event_conditions": [ + { + "field": "field_value", + "comparison_type": 1, + "value": "value_value", + "negated": True, + } + ], + "source_copy_parameters": True, + "parameter_mutations": [ + {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} + ], + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.UpdateEventCreateRuleRequest.meta.fields[ + "event_create_rule" + ] + + 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["event_create_rule"].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["event_create_rule"][field])): + del request_init["event_create_rule"][field][i][subfield] + else: + del request_init["event_create_rule"][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 = analytics_admin.FetchConnectedGa4PropertyResponse( - property="property_value", + return_value = event_create_and_edit.EventCreateRule( + name="name_value", + destination_event="destination_event_value", + source_copy_parameters=True, ) # Wrap the value into a proper Response obj @@ -111847,22 +117025,22 @@ def test_fetch_connected_ga4_property_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.FetchConnectedGa4PropertyResponse.pb( - return_value - ) + return_value = event_create_and_edit.EventCreateRule.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_connected_ga4_property(request) + response = client.update_event_create_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.FetchConnectedGa4PropertyResponse) - assert response.property == "property_value" + assert isinstance(response, event_create_and_edit.EventCreateRule) + assert response.name == "name_value" + assert response.destination_event == "destination_event_value" + assert response.source_copy_parameters is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_fetch_connected_ga4_property_rest_interceptors(null_interceptor): +def test_update_event_create_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -111876,20 +117054,18 @@ def test_fetch_connected_ga4_property_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_fetch_connected_ga4_property", + transports.AnalyticsAdminServiceRestInterceptor, "post_update_event_create_rule" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_fetch_connected_ga4_property_with_metadata", + "post_update_event_create_rule_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_fetch_connected_ga4_property", + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_event_create_rule" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.FetchConnectedGa4PropertyRequest.pb( - analytics_admin.FetchConnectedGa4PropertyRequest() + pb_message = analytics_admin.UpdateEventCreateRuleRequest.pb( + analytics_admin.UpdateEventCreateRuleRequest() ) transcode.return_value = { "method": "post", @@ -111901,24 +117077,24 @@ def test_fetch_connected_ga4_property_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 = analytics_admin.FetchConnectedGa4PropertyResponse.to_json( - analytics_admin.FetchConnectedGa4PropertyResponse() + return_value = event_create_and_edit.EventCreateRule.to_json( + event_create_and_edit.EventCreateRule() ) req.return_value.content = return_value - request = analytics_admin.FetchConnectedGa4PropertyRequest() + request = analytics_admin.UpdateEventCreateRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.FetchConnectedGa4PropertyResponse() + post.return_value = event_create_and_edit.EventCreateRule() post_with_metadata.return_value = ( - analytics_admin.FetchConnectedGa4PropertyResponse(), + event_create_and_edit.EventCreateRule(), metadata, ) - client.fetch_connected_ga4_property( + client.update_event_create_rule( request, metadata=[ ("key", "val"), @@ -111931,14 +117107,16 @@ def test_fetch_connected_ga4_property_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_ad_sense_link_rest_bad_request( - request_type=analytics_admin.GetAdSenseLinkRequest, +def test_delete_event_create_rule_rest_bad_request( + request_type=analytics_admin.DeleteEventCreateRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/adSenseLinks/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -111953,53 +117131,47 @@ def test_get_ad_sense_link_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_ad_sense_link(request) + client.delete_event_create_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetAdSenseLinkRequest, + analytics_admin.DeleteEventCreateRuleRequest, dict, ], ) -def test_get_ad_sense_link_rest_call_success(request_type): +def test_delete_event_create_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/adSenseLinks/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventCreateRules/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 = resources.AdSenseLink( - name="name_value", - ad_client_code="ad_client_code_value", - ) + return_value = None # 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.AdSenseLink.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"} - response = client.get_ad_sense_link(request) + response = client.delete_event_create_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.AdSenseLink) - assert response.name == "name_value" - assert response.ad_client_code == "ad_client_code_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_ad_sense_link_rest_interceptors(null_interceptor): +def test_delete_event_create_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112013,18 +117185,11 @@ def test_get_ad_sense_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_ad_sense_link" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_get_ad_sense_link_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_ad_sense_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_event_create_rule" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetAdSenseLinkRequest.pb( - analytics_admin.GetAdSenseLinkRequest() + pb_message = analytics_admin.DeleteEventCreateRuleRequest.pb( + analytics_admin.DeleteEventCreateRuleRequest() ) transcode.return_value = { "method": "post", @@ -112036,19 +117201,15 @@ def test_get_ad_sense_link_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.AdSenseLink.to_json(resources.AdSenseLink()) - req.return_value.content = return_value - request = analytics_admin.GetAdSenseLinkRequest() + request = analytics_admin.DeleteEventCreateRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.AdSenseLink() - post_with_metadata.return_value = resources.AdSenseLink(), metadata - client.get_ad_sense_link( + client.delete_event_create_rule( request, metadata=[ ("key", "val"), @@ -112057,18 +117218,18 @@ def test_get_ad_sense_link_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_create_ad_sense_link_rest_bad_request( - request_type=analytics_admin.CreateAdSenseLinkRequest, +def test_get_event_edit_rule_rest_bad_request( + request_type=analytics_admin.GetEventEditRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -112083,102 +117244,34 @@ def test_create_ad_sense_link_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_ad_sense_link(request) + client.get_event_edit_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateAdSenseLinkRequest, + analytics_admin.GetEventEditRuleRequest, dict, ], ) -def test_create_ad_sense_link_rest_call_success(request_type): +def test_get_event_edit_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["adsense_link"] = { - "name": "name_value", - "ad_client_code": "ad_client_code_value", + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" } - # 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 = analytics_admin.CreateAdSenseLinkRequest.meta.fields["adsense_link"] - - 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["adsense_link"].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["adsense_link"][field])): - del request_init["adsense_link"][field][i][subfield] - else: - del request_init["adsense_link"][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 = resources.AdSenseLink( + return_value = event_create_and_edit.EventEditRule( name="name_value", - ad_client_code="ad_client_code_value", + display_name="display_name_value", + processing_order=1720, ) # Wrap the value into a proper Response obj @@ -112186,21 +117279,22 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.AdSenseLink.pb(return_value) + return_value = event_create_and_edit.EventEditRule.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.create_ad_sense_link(request) + response = client.get_event_edit_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.AdSenseLink) + assert isinstance(response, event_create_and_edit.EventEditRule) assert response.name == "name_value" - assert response.ad_client_code == "ad_client_code_value" + assert response.display_name == "display_name_value" + assert response.processing_order == 1720 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_ad_sense_link_rest_interceptors(null_interceptor): +def test_get_event_edit_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112214,18 +117308,18 @@ def test_create_ad_sense_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_ad_sense_link" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_event_edit_rule" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_ad_sense_link_with_metadata", + "post_get_event_edit_rule_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_ad_sense_link" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_event_edit_rule" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateAdSenseLinkRequest.pb( - analytics_admin.CreateAdSenseLinkRequest() + pb_message = analytics_admin.GetEventEditRuleRequest.pb( + analytics_admin.GetEventEditRuleRequest() ) transcode.return_value = { "method": "post", @@ -112237,19 +117331,24 @@ def test_create_ad_sense_link_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.AdSenseLink.to_json(resources.AdSenseLink()) + return_value = event_create_and_edit.EventEditRule.to_json( + event_create_and_edit.EventEditRule() + ) req.return_value.content = return_value - request = analytics_admin.CreateAdSenseLinkRequest() + request = analytics_admin.GetEventEditRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.AdSenseLink() - post_with_metadata.return_value = resources.AdSenseLink(), metadata + post.return_value = event_create_and_edit.EventEditRule() + post_with_metadata.return_value = ( + event_create_and_edit.EventEditRule(), + metadata, + ) - client.create_ad_sense_link( + client.get_event_edit_rule( request, metadata=[ ("key", "val"), @@ -112262,14 +117361,14 @@ def test_create_ad_sense_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_ad_sense_link_rest_bad_request( - request_type=analytics_admin.DeleteAdSenseLinkRequest, +def test_list_event_edit_rules_rest_bad_request( + request_type=analytics_admin.ListEventEditRulesRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/adSenseLinks/sample2"} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -112284,45 +117383,51 @@ def test_delete_ad_sense_link_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_ad_sense_link(request) + client.list_event_edit_rules(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteAdSenseLinkRequest, + analytics_admin.ListEventEditRulesRequest, dict, ], ) -def test_delete_ad_sense_link_rest_call_success(request_type): +def test_list_event_edit_rules_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/adSenseLinks/sample2"} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.ListEventEditRulesResponse( + next_page_token="next_page_token_value", + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = analytics_admin.ListEventEditRulesResponse.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_ad_sense_link(request) + response = client.list_event_edit_rules(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, pagers.ListEventEditRulesPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_ad_sense_link_rest_interceptors(null_interceptor): +def test_list_event_edit_rules_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112336,11 +117441,18 @@ def test_delete_ad_sense_link_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_ad_sense_link" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_event_edit_rules" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_event_edit_rules_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_event_edit_rules" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteAdSenseLinkRequest.pb( - analytics_admin.DeleteAdSenseLinkRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ListEventEditRulesRequest.pb( + analytics_admin.ListEventEditRulesRequest() ) transcode.return_value = { "method": "post", @@ -112352,15 +117464,24 @@ def test_delete_ad_sense_link_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 = analytics_admin.ListEventEditRulesResponse.to_json( + analytics_admin.ListEventEditRulesResponse() + ) + req.return_value.content = return_value - request = analytics_admin.DeleteAdSenseLinkRequest() + request = analytics_admin.ListEventEditRulesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = analytics_admin.ListEventEditRulesResponse() + post_with_metadata.return_value = ( + analytics_admin.ListEventEditRulesResponse(), + metadata, + ) - client.delete_ad_sense_link( + client.list_event_edit_rules( request, metadata=[ ("key", "val"), @@ -112369,16 +117490,18 @@ def test_delete_ad_sense_link_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_list_ad_sense_links_rest_bad_request( - request_type=analytics_admin.ListAdSenseLinksRequest, +def test_create_event_edit_rule_rest_bad_request( + request_type=analytics_admin.CreateEventEditRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -112393,30 +117516,117 @@ def test_list_ad_sense_links_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.list_ad_sense_links(request) + client.create_event_edit_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListAdSenseLinksRequest, + analytics_admin.CreateEventEditRuleRequest, dict, ], ) -def test_list_ad_sense_links_rest_call_success(request_type): +def test_create_event_edit_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init["event_edit_rule"] = { + "name": "name_value", + "display_name": "display_name_value", + "event_conditions": [ + { + "field": "field_value", + "comparison_type": 1, + "value": "value_value", + "negated": True, + } + ], + "parameter_mutations": [ + {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} + ], + "processing_order": 1720, + } + # 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 = analytics_admin.CreateEventEditRuleRequest.meta.fields[ + "event_edit_rule" + ] + + 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["event_edit_rule"].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["event_edit_rule"][field])): + del request_init["event_edit_rule"][field][i][subfield] + else: + del request_init["event_edit_rule"][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 = analytics_admin.ListAdSenseLinksResponse( - next_page_token="next_page_token_value", + return_value = event_create_and_edit.EventEditRule( + name="name_value", + display_name="display_name_value", + processing_order=1720, ) # Wrap the value into a proper Response obj @@ -112424,20 +117634,22 @@ def test_list_ad_sense_links_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListAdSenseLinksResponse.pb(return_value) + return_value = event_create_and_edit.EventEditRule.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_ad_sense_links(request) + response = client.create_event_edit_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAdSenseLinksPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, event_create_and_edit.EventEditRule) + assert response.name == "name_value" + assert response.display_name == "display_name_value" + assert response.processing_order == 1720 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_ad_sense_links_rest_interceptors(null_interceptor): +def test_create_event_edit_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112451,18 +117663,18 @@ def test_list_ad_sense_links_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_ad_sense_links" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_event_edit_rule" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_ad_sense_links_with_metadata", + "post_create_event_edit_rule_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_ad_sense_links" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_event_edit_rule" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListAdSenseLinksRequest.pb( - analytics_admin.ListAdSenseLinksRequest() + pb_message = analytics_admin.CreateEventEditRuleRequest.pb( + analytics_admin.CreateEventEditRuleRequest() ) transcode.return_value = { "method": "post", @@ -112474,24 +117686,24 @@ def test_list_ad_sense_links_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 = analytics_admin.ListAdSenseLinksResponse.to_json( - analytics_admin.ListAdSenseLinksResponse() + return_value = event_create_and_edit.EventEditRule.to_json( + event_create_and_edit.EventEditRule() ) req.return_value.content = return_value - request = analytics_admin.ListAdSenseLinksRequest() + request = analytics_admin.CreateEventEditRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListAdSenseLinksResponse() + post.return_value = event_create_and_edit.EventEditRule() post_with_metadata.return_value = ( - analytics_admin.ListAdSenseLinksResponse(), + event_create_and_edit.EventEditRule(), metadata, ) - client.list_ad_sense_links( + client.create_event_edit_rule( request, metadata=[ ("key", "val"), @@ -112504,15 +117716,17 @@ def test_list_ad_sense_links_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_event_create_rule_rest_bad_request( - request_type=analytics_admin.GetEventCreateRuleRequest, +def test_update_event_edit_rule_rest_bad_request( + request_type=analytics_admin.UpdateEventEditRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + "event_edit_rule": { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + } } request = request_type(**request_init) @@ -112528,34 +117742,121 @@ def test_get_event_create_rule_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_event_create_rule(request) + client.update_event_edit_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetEventCreateRuleRequest, + analytics_admin.UpdateEventEditRuleRequest, dict, ], ) -def test_get_event_create_rule_rest_call_success(request_type): +def test_update_event_edit_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) - # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" - } + # send a request that will satisfy transcoding + request_init = { + "event_edit_rule": { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + } + } + request_init["event_edit_rule"] = { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3", + "display_name": "display_name_value", + "event_conditions": [ + { + "field": "field_value", + "comparison_type": 1, + "value": "value_value", + "negated": True, + } + ], + "parameter_mutations": [ + {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} + ], + "processing_order": 1720, + } + # 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 = analytics_admin.UpdateEventEditRuleRequest.meta.fields[ + "event_edit_rule" + ] + + 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["event_edit_rule"].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["event_edit_rule"][field])): + del request_init["event_edit_rule"][field][i][subfield] + else: + del request_init["event_edit_rule"][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 = event_create_and_edit.EventCreateRule( + return_value = event_create_and_edit.EventEditRule( name="name_value", - destination_event="destination_event_value", - source_copy_parameters=True, + display_name="display_name_value", + processing_order=1720, ) # Wrap the value into a proper Response obj @@ -112563,22 +117864,22 @@ def test_get_event_create_rule_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.pb(return_value) + return_value = event_create_and_edit.EventEditRule.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_event_create_rule(request) + response = client.update_event_edit_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, event_create_and_edit.EventCreateRule) + assert isinstance(response, event_create_and_edit.EventEditRule) assert response.name == "name_value" - assert response.destination_event == "destination_event_value" - assert response.source_copy_parameters is True + assert response.display_name == "display_name_value" + assert response.processing_order == 1720 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_event_create_rule_rest_interceptors(null_interceptor): +def test_update_event_edit_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112592,18 +117893,18 @@ def test_get_event_create_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_event_create_rule" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_event_edit_rule" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_event_create_rule_with_metadata", + "post_update_event_edit_rule_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_event_create_rule" + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_event_edit_rule" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetEventCreateRuleRequest.pb( - analytics_admin.GetEventCreateRuleRequest() + pb_message = analytics_admin.UpdateEventEditRuleRequest.pb( + analytics_admin.UpdateEventEditRuleRequest() ) transcode.return_value = { "method": "post", @@ -112615,24 +117916,24 @@ def test_get_event_create_rule_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 = event_create_and_edit.EventCreateRule.to_json( - event_create_and_edit.EventCreateRule() + return_value = event_create_and_edit.EventEditRule.to_json( + event_create_and_edit.EventEditRule() ) req.return_value.content = return_value - request = analytics_admin.GetEventCreateRuleRequest() + request = analytics_admin.UpdateEventEditRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = event_create_and_edit.EventCreateRule() + post.return_value = event_create_and_edit.EventEditRule() post_with_metadata.return_value = ( - event_create_and_edit.EventCreateRule(), + event_create_and_edit.EventEditRule(), metadata, ) - client.get_event_create_rule( + client.update_event_edit_rule( request, metadata=[ ("key", "val"), @@ -112645,14 +117946,16 @@ def test_get_event_create_rule_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_event_create_rules_rest_bad_request( - request_type=analytics_admin.ListEventCreateRulesRequest, +def test_delete_event_edit_rule_rest_bad_request( + request_type=analytics_admin.DeleteEventEditRuleRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -112667,51 +117970,47 @@ def test_list_event_create_rules_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.list_event_create_rules(request) + client.delete_event_edit_rule(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListEventCreateRulesRequest, + analytics_admin.DeleteEventEditRuleRequest, dict, ], ) -def test_list_event_create_rules_rest_call_success(request_type): +def test_delete_event_edit_rule_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = { + "name": "properties/sample1/dataStreams/sample2/eventEditRules/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 = analytics_admin.ListEventCreateRulesResponse( - next_page_token="next_page_token_value", - ) + return_value = None # 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 = analytics_admin.ListEventCreateRulesResponse.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"} - response = client.list_event_create_rules(request) + response = client.delete_event_edit_rule(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListEventCreateRulesPager) - assert response.next_page_token == "next_page_token_value" + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_event_create_rules_rest_interceptors(null_interceptor): +def test_delete_event_edit_rule_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112725,18 +118024,11 @@ def test_list_event_create_rules_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_event_create_rules" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_list_event_create_rules_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_event_create_rules" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_event_edit_rule" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListEventCreateRulesRequest.pb( - analytics_admin.ListEventCreateRulesRequest() + pb_message = analytics_admin.DeleteEventEditRuleRequest.pb( + analytics_admin.DeleteEventEditRuleRequest() ) transcode.return_value = { "method": "post", @@ -112748,24 +118040,15 @@ def test_list_event_create_rules_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 = analytics_admin.ListEventCreateRulesResponse.to_json( - analytics_admin.ListEventCreateRulesResponse() - ) - req.return_value.content = return_value - request = analytics_admin.ListEventCreateRulesRequest() + request = analytics_admin.DeleteEventEditRuleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListEventCreateRulesResponse() - post_with_metadata.return_value = ( - analytics_admin.ListEventCreateRulesResponse(), - metadata, - ) - client.list_event_create_rules( + client.delete_event_edit_rule( request, metadata=[ ("key", "val"), @@ -112774,12 +118057,10 @@ def test_list_event_create_rules_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_create_event_create_rule_rest_bad_request( - request_type=analytics_admin.CreateEventCreateRuleRequest, +def test_reorder_event_edit_rules_rest_bad_request( + request_type=analytics_admin.ReorderEventEditRulesRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -112800,140 +118081,45 @@ def test_create_event_create_rule_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_event_create_rule(request) + client.reorder_event_edit_rules(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateEventCreateRuleRequest, + analytics_admin.ReorderEventEditRulesRequest, dict, ], ) -def test_create_event_create_rule_rest_call_success(request_type): +def test_reorder_event_edit_rules_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1/dataStreams/sample2"} - request_init["event_create_rule"] = { - "name": "name_value", - "destination_event": "destination_event_value", - "event_conditions": [ - { - "field": "field_value", - "comparison_type": 1, - "value": "value_value", - "negated": True, - } - ], - "source_copy_parameters": True, - "parameter_mutations": [ - {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} - ], - } - # The version of a generated dependency at test runtime may differ from the version used during generation. - # Delete any fields which are not present in the current runtime dependency - # See https://github.com/googleapis/gapic-generator-python/issues/1748 - - # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateEventCreateRuleRequest.meta.fields[ - "event_create_rule" - ] - - 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["event_create_rule"].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["event_create_rule"][field])): - del request_init["event_create_rule"][field][i][subfield] - else: - del request_init["event_create_rule"][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 = event_create_and_edit.EventCreateRule( - name="name_value", - destination_event="destination_event_value", - source_copy_parameters=True, - ) + return_value = None # 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 = event_create_and_edit.EventCreateRule.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"} - response = client.create_event_create_rule(request) + response = client.reorder_event_edit_rules(request) # Establish that the response is the type that we expect. - assert isinstance(response, event_create_and_edit.EventCreateRule) - assert response.name == "name_value" - assert response.destination_event == "destination_event_value" - assert response.source_copy_parameters is True + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_event_create_rule_rest_interceptors(null_interceptor): +def test_reorder_event_edit_rules_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -112947,18 +118133,11 @@ def test_create_event_create_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_event_create_rule" - ) as post, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_create_event_create_rule_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_event_create_rule" + transports.AnalyticsAdminServiceRestInterceptor, "pre_reorder_event_edit_rules" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateEventCreateRuleRequest.pb( - analytics_admin.CreateEventCreateRuleRequest() + pb_message = analytics_admin.ReorderEventEditRulesRequest.pb( + analytics_admin.ReorderEventEditRulesRequest() ) transcode.return_value = { "method": "post", @@ -112970,24 +118149,15 @@ def test_create_event_create_rule_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 = event_create_and_edit.EventCreateRule.to_json( - event_create_and_edit.EventCreateRule() - ) - req.return_value.content = return_value - request = analytics_admin.CreateEventCreateRuleRequest() + request = analytics_admin.ReorderEventEditRulesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = event_create_and_edit.EventCreateRule() - post_with_metadata.return_value = ( - event_create_and_edit.EventCreateRule(), - metadata, - ) - client.create_event_create_rule( + client.reorder_event_edit_rules( request, metadata=[ ("key", "val"), @@ -112996,20 +118166,18 @@ def test_create_event_create_rule_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_update_event_create_rule_rest_bad_request( - request_type=analytics_admin.UpdateEventCreateRuleRequest, +def test_update_data_redaction_settings_rest_bad_request( + request_type=analytics_admin.UpdateDataRedactionSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "event_create_rule": { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + "data_redaction_settings": { + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" } } request = request_type(**request_init) @@ -113026,41 +118194,34 @@ def test_update_event_create_rule_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_event_create_rule(request) + client.update_data_redaction_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateEventCreateRuleRequest, + analytics_admin.UpdateDataRedactionSettingsRequest, dict, ], ) -def test_update_event_create_rule_rest_call_success(request_type): +def test_update_data_redaction_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "event_create_rule": { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3" + "data_redaction_settings": { + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" } } - request_init["event_create_rule"] = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/sample3", - "destination_event": "destination_event_value", - "event_conditions": [ - { - "field": "field_value", - "comparison_type": 1, - "value": "value_value", - "negated": True, - } - ], - "source_copy_parameters": True, - "parameter_mutations": [ - {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} + request_init["data_redaction_settings"] = { + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings", + "email_redaction_enabled": True, + "query_parameter_redaction_enabled": True, + "query_parameter_keys": [ + "query_parameter_keys_value1", + "query_parameter_keys_value2", ], } # The version of a generated dependency at test runtime may differ from the version used during generation. @@ -113068,8 +118229,8 @@ def test_update_event_create_rule_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 = analytics_admin.UpdateEventCreateRuleRequest.meta.fields[ - "event_create_rule" + test_field = analytics_admin.UpdateDataRedactionSettingsRequest.meta.fields[ + "data_redaction_settings" ] def get_message_fields(field): @@ -113098,7 +118259,9 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["event_create_rule"].items(): # pragma: NO COVER + for field, value in request_init[ + "data_redaction_settings" + ].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -113128,19 +118291,20 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["event_create_rule"][field])): - del request_init["event_create_rule"][field][i][subfield] + for i in range(0, len(request_init["data_redaction_settings"][field])): + del request_init["data_redaction_settings"][field][i][subfield] else: - del request_init["event_create_rule"][field][subfield] + del request_init["data_redaction_settings"][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 = event_create_and_edit.EventCreateRule( + return_value = resources.DataRedactionSettings( name="name_value", - destination_event="destination_event_value", - source_copy_parameters=True, + email_redaction_enabled=True, + query_parameter_redaction_enabled=True, + query_parameter_keys=["query_parameter_keys_value"], ) # Wrap the value into a proper Response obj @@ -113148,22 +118312,23 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventCreateRule.pb(return_value) + return_value = resources.DataRedactionSettings.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_event_create_rule(request) + response = client.update_data_redaction_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, event_create_and_edit.EventCreateRule) + assert isinstance(response, resources.DataRedactionSettings) assert response.name == "name_value" - assert response.destination_event == "destination_event_value" - assert response.source_copy_parameters is True + assert response.email_redaction_enabled is True + assert response.query_parameter_redaction_enabled is True + assert response.query_parameter_keys == ["query_parameter_keys_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_event_create_rule_rest_interceptors(null_interceptor): +def test_update_data_redaction_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -113177,18 +118342,20 @@ def test_update_event_create_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_event_create_rule" + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_data_redaction_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_event_create_rule_with_metadata", + "post_update_data_redaction_settings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_event_create_rule" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_update_data_redaction_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateEventCreateRuleRequest.pb( - analytics_admin.UpdateEventCreateRuleRequest() + pb_message = analytics_admin.UpdateDataRedactionSettingsRequest.pb( + analytics_admin.UpdateDataRedactionSettingsRequest() ) transcode.return_value = { "method": "post", @@ -113200,24 +118367,21 @@ def test_update_event_create_rule_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 = event_create_and_edit.EventCreateRule.to_json( - event_create_and_edit.EventCreateRule() + return_value = resources.DataRedactionSettings.to_json( + resources.DataRedactionSettings() ) req.return_value.content = return_value - request = analytics_admin.UpdateEventCreateRuleRequest() + request = analytics_admin.UpdateDataRedactionSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = event_create_and_edit.EventCreateRule() - post_with_metadata.return_value = ( - event_create_and_edit.EventCreateRule(), - metadata, - ) + post.return_value = resources.DataRedactionSettings() + post_with_metadata.return_value = resources.DataRedactionSettings(), metadata - client.update_event_create_rule( + client.update_data_redaction_settings( request, metadata=[ ("key", "val"), @@ -113230,128 +118394,15 @@ def test_update_event_create_rule_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_event_create_rule_rest_bad_request( - request_type=analytics_admin.DeleteEventCreateRuleRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/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_event_create_rule(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.DeleteEventCreateRuleRequest, - dict, - ], -) -def test_delete_event_create_rule_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/eventCreateRules/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 = 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_event_create_rule(request) - - # Establish that the response is the type that we expect. - assert response is None - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_event_create_rule_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "pre_delete_event_create_rule" - ) as pre: - pre.assert_not_called() - pb_message = analytics_admin.DeleteEventCreateRuleRequest.pb( - analytics_admin.DeleteEventCreateRuleRequest() - ) - 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"} - - request = analytics_admin.DeleteEventCreateRuleRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - - client.delete_event_create_rule( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - - -def test_get_event_edit_rule_rest_bad_request( - request_type=analytics_admin.GetEventEditRuleRequest, +def test_get_data_redaction_settings_rest_bad_request( + request_type=analytics_admin.GetDataRedactionSettingsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" } request = request_type(**request_init) @@ -113367,34 +118418,35 @@ def test_get_event_edit_rule_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_event_edit_rule(request) + client.get_data_redaction_settings(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetEventEditRuleRequest, + analytics_admin.GetDataRedactionSettingsRequest, dict, ], ) -def test_get_event_edit_rule_rest_call_success(request_type): +def test_get_data_redaction_settings_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" } 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 = event_create_and_edit.EventEditRule( + return_value = resources.DataRedactionSettings( name="name_value", - display_name="display_name_value", - processing_order=1720, + email_redaction_enabled=True, + query_parameter_redaction_enabled=True, + query_parameter_keys=["query_parameter_keys_value"], ) # Wrap the value into a proper Response obj @@ -113402,22 +118454,23 @@ def test_get_event_edit_rule_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventEditRule.pb(return_value) + return_value = resources.DataRedactionSettings.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_event_edit_rule(request) + response = client.get_data_redaction_settings(request) # Establish that the response is the type that we expect. - assert isinstance(response, event_create_and_edit.EventEditRule) + assert isinstance(response, resources.DataRedactionSettings) assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.processing_order == 1720 + assert response.email_redaction_enabled is True + assert response.query_parameter_redaction_enabled is True + assert response.query_parameter_keys == ["query_parameter_keys_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_event_edit_rule_rest_interceptors(null_interceptor): +def test_get_data_redaction_settings_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -113431,18 +118484,20 @@ def test_get_event_edit_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, + "post_get_data_redaction_settings", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_event_edit_rule_with_metadata", + "post_get_data_redaction_settings_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_get_data_redaction_settings", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetEventEditRuleRequest.pb( - analytics_admin.GetEventEditRuleRequest() + pb_message = analytics_admin.GetDataRedactionSettingsRequest.pb( + analytics_admin.GetDataRedactionSettingsRequest() ) transcode.return_value = { "method": "post", @@ -113454,24 +118509,21 @@ def test_get_event_edit_rule_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 = event_create_and_edit.EventEditRule.to_json( - event_create_and_edit.EventEditRule() + return_value = resources.DataRedactionSettings.to_json( + resources.DataRedactionSettings() ) req.return_value.content = return_value - request = analytics_admin.GetEventEditRuleRequest() + request = analytics_admin.GetDataRedactionSettingsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = event_create_and_edit.EventEditRule() - post_with_metadata.return_value = ( - event_create_and_edit.EventEditRule(), - metadata, - ) + post.return_value = resources.DataRedactionSettings() + post_with_metadata.return_value = resources.DataRedactionSettings(), metadata - client.get_event_edit_rule( + client.get_data_redaction_settings( request, metadata=[ ("key", "val"), @@ -113484,14 +118536,14 @@ def test_get_event_edit_rule_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_event_edit_rules_rest_bad_request( - request_type=analytics_admin.ListEventEditRulesRequest, +def test_get_calculated_metric_rest_bad_request( + request_type=analytics_admin.GetCalculatedMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -113506,30 +118558,39 @@ def test_list_event_edit_rules_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.list_event_edit_rules(request) + client.get_calculated_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListEventEditRulesRequest, + analytics_admin.GetCalculatedMetricRequest, dict, ], ) -def test_list_event_edit_rules_rest_call_success(request_type): +def test_get_calculated_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/calculatedMetrics/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 = analytics_admin.ListEventEditRulesResponse( - next_page_token="next_page_token_value", + return_value = resources.CalculatedMetric( + name="name_value", + description="description_value", + display_name="display_name_value", + calculated_metric_id="calculated_metric_id_value", + metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, + restricted_metric_type=[ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ], + formula="formula_value", + invalid_metric_reference=True, ) # Wrap the value into a proper Response obj @@ -113537,20 +118598,29 @@ def test_list_event_edit_rules_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListEventEditRulesResponse.pb(return_value) + return_value = resources.CalculatedMetric.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_event_edit_rules(request) + response = client.get_calculated_metric(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListEventEditRulesPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, resources.CalculatedMetric) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.display_name == "display_name_value" + assert response.calculated_metric_id == "calculated_metric_id_value" + assert response.metric_unit == resources.CalculatedMetric.MetricUnit.STANDARD + assert response.restricted_metric_type == [ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ] + assert response.formula == "formula_value" + assert response.invalid_metric_reference is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_event_edit_rules_rest_interceptors(null_interceptor): +def test_get_calculated_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -113564,18 +118634,18 @@ def test_list_event_edit_rules_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_list_event_edit_rules" + transports.AnalyticsAdminServiceRestInterceptor, "post_get_calculated_metric" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_event_edit_rules_with_metadata", + "post_get_calculated_metric_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_event_edit_rules" + transports.AnalyticsAdminServiceRestInterceptor, "pre_get_calculated_metric" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListEventEditRulesRequest.pb( - analytics_admin.ListEventEditRulesRequest() + pb_message = analytics_admin.GetCalculatedMetricRequest.pb( + analytics_admin.GetCalculatedMetricRequest() ) transcode.return_value = { "method": "post", @@ -113587,24 +118657,19 @@ def test_list_event_edit_rules_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 = analytics_admin.ListEventEditRulesResponse.to_json( - analytics_admin.ListEventEditRulesResponse() - ) + return_value = resources.CalculatedMetric.to_json(resources.CalculatedMetric()) req.return_value.content = return_value - request = analytics_admin.ListEventEditRulesRequest() + request = analytics_admin.GetCalculatedMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListEventEditRulesResponse() - post_with_metadata.return_value = ( - analytics_admin.ListEventEditRulesResponse(), - metadata, - ) + post.return_value = resources.CalculatedMetric() + post_with_metadata.return_value = resources.CalculatedMetric(), metadata - client.list_event_edit_rules( + client.get_calculated_metric( request, metadata=[ ("key", "val"), @@ -113617,14 +118682,14 @@ def test_list_event_edit_rules_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_event_edit_rule_rest_bad_request( - request_type=analytics_admin.CreateEventEditRuleRequest, +def test_create_calculated_metric_rest_bad_request( + request_type=analytics_admin.CreateCalculatedMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -113639,46 +118704,40 @@ def test_create_event_edit_rule_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_event_edit_rule(request) + client.create_calculated_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateEventEditRuleRequest, + analytics_admin.CreateCalculatedMetricRequest, dict, ], ) -def test_create_event_edit_rule_rest_call_success(request_type): +def test_create_calculated_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} - request_init["event_edit_rule"] = { + request_init = {"parent": "properties/sample1"} + request_init["calculated_metric"] = { "name": "name_value", + "description": "description_value", "display_name": "display_name_value", - "event_conditions": [ - { - "field": "field_value", - "comparison_type": 1, - "value": "value_value", - "negated": True, - } - ], - "parameter_mutations": [ - {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} - ], - "processing_order": 1720, + "calculated_metric_id": "calculated_metric_id_value", + "metric_unit": 1, + "restricted_metric_type": [1], + "formula": "formula_value", + "invalid_metric_reference": True, } # 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 = analytics_admin.CreateEventEditRuleRequest.meta.fields[ - "event_edit_rule" + test_field = analytics_admin.CreateCalculatedMetricRequest.meta.fields[ + "calculated_metric" ] def get_message_fields(field): @@ -113707,7 +118766,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["event_edit_rule"].items(): # pragma: NO COVER + for field, value in request_init["calculated_metric"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -113737,19 +118796,26 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["event_edit_rule"][field])): - del request_init["event_edit_rule"][field][i][subfield] + for i in range(0, len(request_init["calculated_metric"][field])): + del request_init["calculated_metric"][field][i][subfield] else: - del request_init["event_edit_rule"][field][subfield] + del request_init["calculated_metric"][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 = event_create_and_edit.EventEditRule( + return_value = resources.CalculatedMetric( name="name_value", + description="description_value", display_name="display_name_value", - processing_order=1720, + calculated_metric_id="calculated_metric_id_value", + metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, + restricted_metric_type=[ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ], + formula="formula_value", + invalid_metric_reference=True, ) # Wrap the value into a proper Response obj @@ -113757,22 +118823,29 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventEditRule.pb(return_value) + return_value = resources.CalculatedMetric.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.create_event_edit_rule(request) + response = client.create_calculated_metric(request) # Establish that the response is the type that we expect. - assert isinstance(response, event_create_and_edit.EventEditRule) + assert isinstance(response, resources.CalculatedMetric) assert response.name == "name_value" + assert response.description == "description_value" assert response.display_name == "display_name_value" - assert response.processing_order == 1720 + assert response.calculated_metric_id == "calculated_metric_id_value" + assert response.metric_unit == resources.CalculatedMetric.MetricUnit.STANDARD + assert response.restricted_metric_type == [ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ] + assert response.formula == "formula_value" + assert response.invalid_metric_reference is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_event_edit_rule_rest_interceptors(null_interceptor): +def test_create_calculated_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -113786,18 +118859,18 @@ def test_create_event_edit_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, "post_create_calculated_metric" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_event_edit_rule_with_metadata", + "post_create_calculated_metric_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_calculated_metric" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateEventEditRuleRequest.pb( - analytics_admin.CreateEventEditRuleRequest() + pb_message = analytics_admin.CreateCalculatedMetricRequest.pb( + analytics_admin.CreateCalculatedMetricRequest() ) transcode.return_value = { "method": "post", @@ -113809,24 +118882,19 @@ def test_create_event_edit_rule_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 = event_create_and_edit.EventEditRule.to_json( - event_create_and_edit.EventEditRule() - ) + return_value = resources.CalculatedMetric.to_json(resources.CalculatedMetric()) req.return_value.content = return_value - request = analytics_admin.CreateEventEditRuleRequest() + request = analytics_admin.CreateCalculatedMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = event_create_and_edit.EventEditRule() - post_with_metadata.return_value = ( - event_create_and_edit.EventEditRule(), - metadata, - ) + post.return_value = resources.CalculatedMetric() + post_with_metadata.return_value = resources.CalculatedMetric(), metadata - client.create_event_edit_rule( + client.create_calculated_metric( request, metadata=[ ("key", "val"), @@ -113839,18 +118907,14 @@ def test_create_event_edit_rule_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_event_edit_rule_rest_bad_request( - request_type=analytics_admin.UpdateEventEditRuleRequest, +def test_list_calculated_metrics_rest_bad_request( + request_type=analytics_admin.ListCalculatedMetricsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "event_edit_rule": { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" - } - } + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -113865,121 +118929,30 @@ def test_update_event_edit_rule_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_event_edit_rule(request) + client.list_calculated_metrics(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateEventEditRuleRequest, + analytics_admin.ListCalculatedMetricsRequest, dict, ], ) -def test_update_event_edit_rule_rest_call_success(request_type): +def test_list_calculated_metrics_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "event_edit_rule": { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" - } - } - request_init["event_edit_rule"] = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3", - "display_name": "display_name_value", - "event_conditions": [ - { - "field": "field_value", - "comparison_type": 1, - "value": "value_value", - "negated": True, - } - ], - "parameter_mutations": [ - {"parameter": "parameter_value", "parameter_value": "parameter_value_value"} - ], - "processing_order": 1720, - } - # 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 = analytics_admin.UpdateEventEditRuleRequest.meta.fields[ - "event_edit_rule" - ] - - 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["event_edit_rule"].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["event_edit_rule"][field])): - del request_init["event_edit_rule"][field][i][subfield] - else: - del request_init["event_edit_rule"][field][subfield] + request_init = {"parent": "properties/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 = event_create_and_edit.EventEditRule( - name="name_value", - display_name="display_name_value", - processing_order=1720, + return_value = analytics_admin.ListCalculatedMetricsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -113987,22 +118960,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = event_create_and_edit.EventEditRule.pb(return_value) + return_value = analytics_admin.ListCalculatedMetricsResponse.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_event_edit_rule(request) + response = client.list_calculated_metrics(request) # Establish that the response is the type that we expect. - assert isinstance(response, event_create_and_edit.EventEditRule) - assert response.name == "name_value" - assert response.display_name == "display_name_value" - assert response.processing_order == 1720 + assert isinstance(response, pagers.ListCalculatedMetricsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_event_edit_rule_rest_interceptors(null_interceptor): +def test_list_calculated_metrics_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114016,18 +118987,18 @@ def test_update_event_edit_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, "post_list_calculated_metrics" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_event_edit_rule_with_metadata", + "post_list_calculated_metrics_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, "pre_list_calculated_metrics" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateEventEditRuleRequest.pb( - analytics_admin.UpdateEventEditRuleRequest() + pb_message = analytics_admin.ListCalculatedMetricsRequest.pb( + analytics_admin.ListCalculatedMetricsRequest() ) transcode.return_value = { "method": "post", @@ -114039,24 +119010,24 @@ def test_update_event_edit_rule_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 = event_create_and_edit.EventEditRule.to_json( - event_create_and_edit.EventEditRule() + return_value = analytics_admin.ListCalculatedMetricsResponse.to_json( + analytics_admin.ListCalculatedMetricsResponse() ) req.return_value.content = return_value - request = analytics_admin.UpdateEventEditRuleRequest() + request = analytics_admin.ListCalculatedMetricsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = event_create_and_edit.EventEditRule() + post.return_value = analytics_admin.ListCalculatedMetricsResponse() post_with_metadata.return_value = ( - event_create_and_edit.EventEditRule(), + analytics_admin.ListCalculatedMetricsResponse(), metadata, ) - client.update_event_edit_rule( + client.list_calculated_metrics( request, metadata=[ ("key", "val"), @@ -114069,15 +119040,15 @@ def test_update_event_edit_rule_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_event_edit_rule_rest_bad_request( - request_type=analytics_admin.DeleteEventEditRuleRequest, +def test_update_calculated_metric_rest_bad_request( + request_type=analytics_admin.UpdateCalculatedMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + "calculated_metric": {"name": "properties/sample1/calculatedMetrics/sample2"} } request = request_type(**request_init) @@ -114093,47 +119064,150 @@ def test_delete_event_edit_rule_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_event_edit_rule(request) + client.update_calculated_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteEventEditRuleRequest, + analytics_admin.UpdateCalculatedMetricRequest, dict, ], ) -def test_delete_event_edit_rule_rest_call_success(request_type): +def test_update_calculated_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "properties/sample1/dataStreams/sample2/eventEditRules/sample3" + "calculated_metric": {"name": "properties/sample1/calculatedMetrics/sample2"} + } + request_init["calculated_metric"] = { + "name": "properties/sample1/calculatedMetrics/sample2", + "description": "description_value", + "display_name": "display_name_value", + "calculated_metric_id": "calculated_metric_id_value", + "metric_unit": 1, + "restricted_metric_type": [1], + "formula": "formula_value", + "invalid_metric_reference": True, } + # 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 = analytics_admin.UpdateCalculatedMetricRequest.meta.fields[ + "calculated_metric" + ] + + 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["calculated_metric"].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["calculated_metric"][field])): + del request_init["calculated_metric"][field][i][subfield] + else: + del request_init["calculated_metric"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = resources.CalculatedMetric( + name="name_value", + description="description_value", + display_name="display_name_value", + calculated_metric_id="calculated_metric_id_value", + metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, + restricted_metric_type=[ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ], + formula="formula_value", + invalid_metric_reference=True, + ) # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = resources.CalculatedMetric.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_event_edit_rule(request) + response = client.update_calculated_metric(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, resources.CalculatedMetric) + assert response.name == "name_value" + assert response.description == "description_value" + assert response.display_name == "display_name_value" + assert response.calculated_metric_id == "calculated_metric_id_value" + assert response.metric_unit == resources.CalculatedMetric.MetricUnit.STANDARD + assert response.restricted_metric_type == [ + resources.CalculatedMetric.RestrictedMetricType.COST_DATA + ] + assert response.formula == "formula_value" + assert response.invalid_metric_reference is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_event_edit_rule_rest_interceptors(null_interceptor): +def test_update_calculated_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114147,11 +119221,18 @@ def test_delete_event_edit_rule_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_event_edit_rule" + transports.AnalyticsAdminServiceRestInterceptor, "post_update_calculated_metric" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_update_calculated_metric_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_update_calculated_metric" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteEventEditRuleRequest.pb( - analytics_admin.DeleteEventEditRuleRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.UpdateCalculatedMetricRequest.pb( + analytics_admin.UpdateCalculatedMetricRequest() ) transcode.return_value = { "method": "post", @@ -114163,15 +119244,19 @@ def test_delete_event_edit_rule_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.CalculatedMetric.to_json(resources.CalculatedMetric()) + req.return_value.content = return_value - request = analytics_admin.DeleteEventEditRuleRequest() + request = analytics_admin.UpdateCalculatedMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = resources.CalculatedMetric() + post_with_metadata.return_value = resources.CalculatedMetric(), metadata - client.delete_event_edit_rule( + client.update_calculated_metric( request, metadata=[ ("key", "val"), @@ -114180,16 +119265,18 @@ def test_delete_event_edit_rule_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_reorder_event_edit_rules_rest_bad_request( - request_type=analytics_admin.ReorderEventEditRulesRequest, +def test_delete_calculated_metric_rest_bad_request( + request_type=analytics_admin.DeleteCalculatedMetricRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -114204,23 +119291,23 @@ def test_reorder_event_edit_rules_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.reorder_event_edit_rules(request) + client.delete_calculated_metric(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ReorderEventEditRulesRequest, + analytics_admin.DeleteCalculatedMetricRequest, dict, ], ) -def test_reorder_event_edit_rules_rest_call_success(request_type): +def test_delete_calculated_metric_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1/dataStreams/sample2"} + request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -114235,14 +119322,14 @@ def test_reorder_event_edit_rules_rest_call_success(request_type): 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.reorder_event_edit_rules(request) + response = client.delete_calculated_metric(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_reorder_event_edit_rules_rest_interceptors(null_interceptor): +def test_delete_calculated_metric_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114256,11 +119343,11 @@ def test_reorder_event_edit_rules_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_reorder_event_edit_rules" + transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_calculated_metric" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.ReorderEventEditRulesRequest.pb( - analytics_admin.ReorderEventEditRulesRequest() + pb_message = analytics_admin.DeleteCalculatedMetricRequest.pb( + analytics_admin.DeleteCalculatedMetricRequest() ) transcode.return_value = { "method": "post", @@ -114273,14 +119360,14 @@ def test_reorder_event_edit_rules_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.ReorderEventEditRulesRequest() + request = analytics_admin.DeleteCalculatedMetricRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.reorder_event_edit_rules( + client.delete_calculated_metric( request, metadata=[ ("key", "val"), @@ -114291,18 +119378,14 @@ def test_reorder_event_edit_rules_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_update_data_redaction_settings_rest_bad_request( - request_type=analytics_admin.UpdateDataRedactionSettingsRequest, +def test_create_rollup_property_rest_bad_request( + request_type=analytics_admin.CreateRollupPropertyRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "data_redaction_settings": { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" - } - } + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -114317,141 +119400,48 @@ def test_update_data_redaction_settings_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_data_redaction_settings(request) + client.create_rollup_property(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateDataRedactionSettingsRequest, + analytics_admin.CreateRollupPropertyRequest, dict, ], ) -def test_update_data_redaction_settings_rest_call_success(request_type): +def test_create_rollup_property_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "data_redaction_settings": { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" - } - } - request_init["data_redaction_settings"] = { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings", - "email_redaction_enabled": True, - "query_parameter_redaction_enabled": True, - "query_parameter_keys": [ - "query_parameter_keys_value1", - "query_parameter_keys_value2", - ], - } - # 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 = analytics_admin.UpdateDataRedactionSettingsRequest.meta.fields[ - "data_redaction_settings" - ] - - 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[ - "data_redaction_settings" - ].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["data_redaction_settings"][field])): - del request_init["data_redaction_settings"][field][i][subfield] - else: - del request_init["data_redaction_settings"][field][subfield] + 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 = resources.DataRedactionSettings( - name="name_value", - email_redaction_enabled=True, - query_parameter_redaction_enabled=True, - query_parameter_keys=["query_parameter_keys_value"], - ) + return_value = analytics_admin.CreateRollupPropertyResponse() # 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.DataRedactionSettings.pb(return_value) + return_value = analytics_admin.CreateRollupPropertyResponse.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_data_redaction_settings(request) + response = client.create_rollup_property(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataRedactionSettings) - assert response.name == "name_value" - assert response.email_redaction_enabled is True - assert response.query_parameter_redaction_enabled is True - assert response.query_parameter_keys == ["query_parameter_keys_value"] + assert isinstance(response, analytics_admin.CreateRollupPropertyResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_data_redaction_settings_rest_interceptors(null_interceptor): +def test_create_rollup_property_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114465,20 +119455,18 @@ def test_update_data_redaction_settings_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "post_update_data_redaction_settings", + transports.AnalyticsAdminServiceRestInterceptor, "post_create_rollup_property" ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_data_redaction_settings_with_metadata", + "post_create_rollup_property_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_data_redaction_settings", + transports.AnalyticsAdminServiceRestInterceptor, "pre_create_rollup_property" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateDataRedactionSettingsRequest.pb( - analytics_admin.UpdateDataRedactionSettingsRequest() + pb_message = analytics_admin.CreateRollupPropertyRequest.pb( + analytics_admin.CreateRollupPropertyRequest() ) transcode.return_value = { "method": "post", @@ -114490,21 +119478,24 @@ def test_update_data_redaction_settings_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.DataRedactionSettings.to_json( - resources.DataRedactionSettings() + return_value = analytics_admin.CreateRollupPropertyResponse.to_json( + analytics_admin.CreateRollupPropertyResponse() ) req.return_value.content = return_value - request = analytics_admin.UpdateDataRedactionSettingsRequest() + request = analytics_admin.CreateRollupPropertyRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataRedactionSettings() - post_with_metadata.return_value = resources.DataRedactionSettings(), metadata + post.return_value = analytics_admin.CreateRollupPropertyResponse() + post_with_metadata.return_value = ( + analytics_admin.CreateRollupPropertyResponse(), + metadata, + ) - client.update_data_redaction_settings( + client.create_rollup_property( request, metadata=[ ("key", "val"), @@ -114517,16 +119508,14 @@ def test_update_data_redaction_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_data_redaction_settings_rest_bad_request( - request_type=analytics_admin.GetDataRedactionSettingsRequest, +def test_get_rollup_property_source_link_rest_bad_request( + request_type=analytics_admin.GetRollupPropertySourceLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" - } + request_init = {"name": "properties/sample1/rollupPropertySourceLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -114541,35 +119530,31 @@ def test_get_data_redaction_settings_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_data_redaction_settings(request) + client.get_rollup_property_source_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetDataRedactionSettingsRequest, + analytics_admin.GetRollupPropertySourceLinkRequest, dict, ], ) -def test_get_data_redaction_settings_rest_call_success(request_type): +def test_get_rollup_property_source_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "properties/sample1/dataStreams/sample2/dataRedactionSettings" - } + request_init = {"name": "properties/sample1/rollupPropertySourceLinks/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 = resources.DataRedactionSettings( + return_value = resources.RollupPropertySourceLink( name="name_value", - email_redaction_enabled=True, - query_parameter_redaction_enabled=True, - query_parameter_keys=["query_parameter_keys_value"], + source_property="source_property_value", ) # Wrap the value into a proper Response obj @@ -114577,23 +119562,21 @@ def test_get_data_redaction_settings_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.DataRedactionSettings.pb(return_value) + return_value = resources.RollupPropertySourceLink.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_data_redaction_settings(request) + response = client.get_rollup_property_source_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.DataRedactionSettings) + assert isinstance(response, resources.RollupPropertySourceLink) assert response.name == "name_value" - assert response.email_redaction_enabled is True - assert response.query_parameter_redaction_enabled is True - assert response.query_parameter_keys == ["query_parameter_keys_value"] + assert response.source_property == "source_property_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_data_redaction_settings_rest_interceptors(null_interceptor): +def test_get_rollup_property_source_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114608,19 +119591,19 @@ def test_get_data_redaction_settings_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_redaction_settings", + "post_get_rollup_property_source_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_data_redaction_settings_with_metadata", + "post_get_rollup_property_source_link_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_data_redaction_settings", + "pre_get_rollup_property_source_link", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetDataRedactionSettingsRequest.pb( - analytics_admin.GetDataRedactionSettingsRequest() + pb_message = analytics_admin.GetRollupPropertySourceLinkRequest.pb( + analytics_admin.GetRollupPropertySourceLinkRequest() ) transcode.return_value = { "method": "post", @@ -114632,21 +119615,21 @@ def test_get_data_redaction_settings_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.DataRedactionSettings.to_json( - resources.DataRedactionSettings() + return_value = resources.RollupPropertySourceLink.to_json( + resources.RollupPropertySourceLink() ) req.return_value.content = return_value - request = analytics_admin.GetDataRedactionSettingsRequest() + request = analytics_admin.GetRollupPropertySourceLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.DataRedactionSettings() - post_with_metadata.return_value = resources.DataRedactionSettings(), metadata + post.return_value = resources.RollupPropertySourceLink() + post_with_metadata.return_value = resources.RollupPropertySourceLink(), metadata - client.get_data_redaction_settings( + client.get_rollup_property_source_link( request, metadata=[ ("key", "val"), @@ -114659,14 +119642,14 @@ def test_get_data_redaction_settings_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_calculated_metric_rest_bad_request( - request_type=analytics_admin.GetCalculatedMetricRequest, +def test_list_rollup_property_source_links_rest_bad_request( + request_type=analytics_admin.ListRollupPropertySourceLinksRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -114681,39 +119664,30 @@ def test_get_calculated_metric_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_calculated_metric(request) + client.list_rollup_property_source_links(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetCalculatedMetricRequest, + analytics_admin.ListRollupPropertySourceLinksRequest, dict, ], ) -def test_get_calculated_metric_rest_call_success(request_type): +def test_list_rollup_property_source_links_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} + request_init = {"parent": "properties/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.CalculatedMetric( - name="name_value", - description="description_value", - display_name="display_name_value", - calculated_metric_id="calculated_metric_id_value", - metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, - restricted_metric_type=[ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ], - formula="formula_value", - invalid_metric_reference=True, + return_value = analytics_admin.ListRollupPropertySourceLinksResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -114721,29 +119695,22 @@ def test_get_calculated_metric_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CalculatedMetric.pb(return_value) + return_value = analytics_admin.ListRollupPropertySourceLinksResponse.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_calculated_metric(request) + response = client.list_rollup_property_source_links(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CalculatedMetric) - assert response.name == "name_value" - assert response.description == "description_value" - assert response.display_name == "display_name_value" - assert response.calculated_metric_id == "calculated_metric_id_value" - assert response.metric_unit == resources.CalculatedMetric.MetricUnit.STANDARD - assert response.restricted_metric_type == [ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ] - assert response.formula == "formula_value" - assert response.invalid_metric_reference is True + assert isinstance(response, pagers.ListRollupPropertySourceLinksPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_calculated_metric_rest_interceptors(null_interceptor): +def test_list_rollup_property_source_links_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114757,18 +119724,20 @@ def test_get_calculated_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_get_calculated_metric" + transports.AnalyticsAdminServiceRestInterceptor, + "post_list_rollup_property_source_links", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_calculated_metric_with_metadata", + "post_list_rollup_property_source_links_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_get_calculated_metric" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_list_rollup_property_source_links", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetCalculatedMetricRequest.pb( - analytics_admin.GetCalculatedMetricRequest() + pb_message = analytics_admin.ListRollupPropertySourceLinksRequest.pb( + analytics_admin.ListRollupPropertySourceLinksRequest() ) transcode.return_value = { "method": "post", @@ -114780,19 +119749,24 @@ def test_get_calculated_metric_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.CalculatedMetric.to_json(resources.CalculatedMetric()) + return_value = analytics_admin.ListRollupPropertySourceLinksResponse.to_json( + analytics_admin.ListRollupPropertySourceLinksResponse() + ) req.return_value.content = return_value - request = analytics_admin.GetCalculatedMetricRequest() + request = analytics_admin.ListRollupPropertySourceLinksRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CalculatedMetric() - post_with_metadata.return_value = resources.CalculatedMetric(), metadata + post.return_value = analytics_admin.ListRollupPropertySourceLinksResponse() + post_with_metadata.return_value = ( + analytics_admin.ListRollupPropertySourceLinksResponse(), + metadata, + ) - client.get_calculated_metric( + client.list_rollup_property_source_links( request, metadata=[ ("key", "val"), @@ -114805,8 +119779,8 @@ def test_get_calculated_metric_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_calculated_metric_rest_bad_request( - request_type=analytics_admin.CreateCalculatedMetricRequest, +def test_create_rollup_property_source_link_rest_bad_request( + request_type=analytics_admin.CreateRollupPropertySourceLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -114827,40 +119801,34 @@ def test_create_calculated_metric_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_calculated_metric(request) + client.create_rollup_property_source_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateCalculatedMetricRequest, + analytics_admin.CreateRollupPropertySourceLinkRequest, dict, ], ) -def test_create_calculated_metric_rest_call_success(request_type): +def test_create_rollup_property_source_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["calculated_metric"] = { + request_init["rollup_property_source_link"] = { "name": "name_value", - "description": "description_value", - "display_name": "display_name_value", - "calculated_metric_id": "calculated_metric_id_value", - "metric_unit": 1, - "restricted_metric_type": [1], - "formula": "formula_value", - "invalid_metric_reference": True, + "source_property": "source_property_value", } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateCalculatedMetricRequest.meta.fields[ - "calculated_metric" + test_field = analytics_admin.CreateRollupPropertySourceLinkRequest.meta.fields[ + "rollup_property_source_link" ] def get_message_fields(field): @@ -114889,7 +119857,9 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for field, value in request_init["calculated_metric"].items(): # pragma: NO COVER + for field, value in request_init[ + "rollup_property_source_link" + ].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -114919,26 +119889,20 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["calculated_metric"][field])): - del request_init["calculated_metric"][field][i][subfield] + for i in range( + 0, len(request_init["rollup_property_source_link"][field]) + ): + del request_init["rollup_property_source_link"][field][i][subfield] else: - del request_init["calculated_metric"][field][subfield] + del request_init["rollup_property_source_link"][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 = resources.CalculatedMetric( + return_value = resources.RollupPropertySourceLink( name="name_value", - description="description_value", - display_name="display_name_value", - calculated_metric_id="calculated_metric_id_value", - metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, - restricted_metric_type=[ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ], - formula="formula_value", - invalid_metric_reference=True, + source_property="source_property_value", ) # Wrap the value into a proper Response obj @@ -114946,29 +119910,21 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.CalculatedMetric.pb(return_value) + return_value = resources.RollupPropertySourceLink.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.create_calculated_metric(request) + response = client.create_rollup_property_source_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CalculatedMetric) + assert isinstance(response, resources.RollupPropertySourceLink) assert response.name == "name_value" - assert response.description == "description_value" - assert response.display_name == "display_name_value" - assert response.calculated_metric_id == "calculated_metric_id_value" - assert response.metric_unit == resources.CalculatedMetric.MetricUnit.STANDARD - assert response.restricted_metric_type == [ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ] - assert response.formula == "formula_value" - assert response.invalid_metric_reference is True + assert response.source_property == "source_property_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_calculated_metric_rest_interceptors(null_interceptor): +def test_create_rollup_property_source_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -114982,146 +119938,20 @@ def test_create_calculated_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_calculated_metric" - ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_calculated_metric_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_calculated_metric" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateCalculatedMetricRequest.pb( - analytics_admin.CreateCalculatedMetricRequest() - ) - 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.CalculatedMetric.to_json(resources.CalculatedMetric()) - req.return_value.content = return_value - - request = analytics_admin.CreateCalculatedMetricRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = resources.CalculatedMetric() - post_with_metadata.return_value = resources.CalculatedMetric(), metadata - - client.create_calculated_metric( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() - - -def test_list_calculated_metrics_rest_bad_request( - request_type=analytics_admin.ListCalculatedMetricsRequest, -): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = {"parent": "properties/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.list_calculated_metrics(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.ListCalculatedMetricsRequest, - dict, - ], -) -def test_list_calculated_metrics_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "properties/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 = analytics_admin.ListCalculatedMetricsResponse( - 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 = analytics_admin.ListCalculatedMetricsResponse.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_calculated_metrics(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListCalculatedMetricsPager) - assert response.next_page_token == "next_page_token_value" - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_calculated_metrics_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_list_calculated_metrics" + "post_create_rollup_property_source_link", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_calculated_metrics_with_metadata", + "post_create_rollup_property_source_link_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_list_calculated_metrics" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_create_rollup_property_source_link", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListCalculatedMetricsRequest.pb( - analytics_admin.ListCalculatedMetricsRequest() + pb_message = analytics_admin.CreateRollupPropertySourceLinkRequest.pb( + analytics_admin.CreateRollupPropertySourceLinkRequest() ) transcode.return_value = { "method": "post", @@ -115133,24 +119963,21 @@ def test_list_calculated_metrics_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 = analytics_admin.ListCalculatedMetricsResponse.to_json( - analytics_admin.ListCalculatedMetricsResponse() + return_value = resources.RollupPropertySourceLink.to_json( + resources.RollupPropertySourceLink() ) req.return_value.content = return_value - request = analytics_admin.ListCalculatedMetricsRequest() + request = analytics_admin.CreateRollupPropertySourceLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListCalculatedMetricsResponse() - post_with_metadata.return_value = ( - analytics_admin.ListCalculatedMetricsResponse(), - metadata, - ) + post.return_value = resources.RollupPropertySourceLink() + post_with_metadata.return_value = resources.RollupPropertySourceLink(), metadata - client.list_calculated_metrics( + client.create_rollup_property_source_link( request, metadata=[ ("key", "val"), @@ -115163,16 +119990,14 @@ def test_list_calculated_metrics_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_calculated_metric_rest_bad_request( - request_type=analytics_admin.UpdateCalculatedMetricRequest, +def test_delete_rollup_property_source_link_rest_bad_request( + request_type=analytics_admin.DeleteRollupPropertySourceLinkRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "calculated_metric": {"name": "properties/sample1/calculatedMetrics/sample2"} - } + request_init = {"name": "properties/sample1/rollupPropertySourceLinks/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -115187,150 +120012,45 @@ def test_update_calculated_metric_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_calculated_metric(request) + client.delete_rollup_property_source_link(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateCalculatedMetricRequest, + analytics_admin.DeleteRollupPropertySourceLinkRequest, dict, ], ) -def test_update_calculated_metric_rest_call_success(request_type): +def test_delete_rollup_property_source_link_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "calculated_metric": {"name": "properties/sample1/calculatedMetrics/sample2"} - } - request_init["calculated_metric"] = { - "name": "properties/sample1/calculatedMetrics/sample2", - "description": "description_value", - "display_name": "display_name_value", - "calculated_metric_id": "calculated_metric_id_value", - "metric_unit": 1, - "restricted_metric_type": [1], - "formula": "formula_value", - "invalid_metric_reference": True, - } - # 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 = analytics_admin.UpdateCalculatedMetricRequest.meta.fields[ - "calculated_metric" - ] - - 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["calculated_metric"].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["calculated_metric"][field])): - del request_init["calculated_metric"][field][i][subfield] - else: - del request_init["calculated_metric"][field][subfield] + request_init = {"name": "properties/sample1/rollupPropertySourceLinks/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 = resources.CalculatedMetric( - name="name_value", - description="description_value", - display_name="display_name_value", - calculated_metric_id="calculated_metric_id_value", - metric_unit=resources.CalculatedMetric.MetricUnit.STANDARD, - restricted_metric_type=[ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ], - formula="formula_value", - invalid_metric_reference=True, - ) + return_value = None # 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.CalculatedMetric.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"} - response = client.update_calculated_metric(request) + response = client.delete_rollup_property_source_link(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.CalculatedMetric) - assert response.name == "name_value" - assert response.description == "description_value" - assert response.display_name == "display_name_value" - assert response.calculated_metric_id == "calculated_metric_id_value" - assert response.metric_unit == resources.CalculatedMetric.MetricUnit.STANDARD - assert response.restricted_metric_type == [ - resources.CalculatedMetric.RestrictedMetricType.COST_DATA - ] - assert response.formula == "formula_value" - assert response.invalid_metric_reference is True + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_calculated_metric_rest_interceptors(null_interceptor): +def test_delete_rollup_property_source_link_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -115344,18 +120064,12 @@ def test_update_calculated_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_update_calculated_metric" - ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_calculated_metric_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_update_calculated_metric" + "pre_delete_rollup_property_source_link", ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateCalculatedMetricRequest.pb( - analytics_admin.UpdateCalculatedMetricRequest() + pb_message = analytics_admin.DeleteRollupPropertySourceLinkRequest.pb( + analytics_admin.DeleteRollupPropertySourceLinkRequest() ) transcode.return_value = { "method": "post", @@ -115367,19 +120081,15 @@ def test_update_calculated_metric_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.CalculatedMetric.to_json(resources.CalculatedMetric()) - req.return_value.content = return_value - request = analytics_admin.UpdateCalculatedMetricRequest() + request = analytics_admin.DeleteRollupPropertySourceLinkRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.CalculatedMetric() - post_with_metadata.return_value = resources.CalculatedMetric(), metadata - client.update_calculated_metric( + client.delete_rollup_property_source_link( request, metadata=[ ("key", "val"), @@ -115388,18 +120098,16 @@ def test_update_calculated_metric_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_delete_calculated_metric_rest_bad_request( - request_type=analytics_admin.DeleteCalculatedMetricRequest, +def test_provision_subproperty_rest_bad_request( + request_type=analytics_admin.ProvisionSubpropertyRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -115414,45 +120122,48 @@ def test_delete_calculated_metric_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_calculated_metric(request) + client.provision_subproperty(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteCalculatedMetricRequest, + analytics_admin.ProvisionSubpropertyRequest, dict, ], ) -def test_delete_calculated_metric_rest_call_success(request_type): +def test_provision_subproperty_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/calculatedMetrics/sample2"} + request_init = {} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = analytics_admin.ProvisionSubpropertyResponse() # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + + # Convert return value to protobuf type + return_value = analytics_admin.ProvisionSubpropertyResponse.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_calculated_metric(request) + response = client.provision_subproperty(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, analytics_admin.ProvisionSubpropertyResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_calculated_metric_rest_interceptors(null_interceptor): +def test_provision_subproperty_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -115466,11 +120177,18 @@ def test_delete_calculated_metric_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_delete_calculated_metric" + transports.AnalyticsAdminServiceRestInterceptor, "post_provision_subproperty" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_provision_subproperty_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_provision_subproperty" ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteCalculatedMetricRequest.pb( - analytics_admin.DeleteCalculatedMetricRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.ProvisionSubpropertyRequest.pb( + analytics_admin.ProvisionSubpropertyRequest() ) transcode.return_value = { "method": "post", @@ -115482,15 +120200,24 @@ def test_delete_calculated_metric_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 = analytics_admin.ProvisionSubpropertyResponse.to_json( + analytics_admin.ProvisionSubpropertyResponse() + ) + req.return_value.content = return_value - request = analytics_admin.DeleteCalculatedMetricRequest() + request = analytics_admin.ProvisionSubpropertyRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = analytics_admin.ProvisionSubpropertyResponse() + post_with_metadata.return_value = ( + analytics_admin.ProvisionSubpropertyResponse(), + metadata, + ) - client.delete_calculated_metric( + client.provision_subproperty( request, metadata=[ ("key", "val"), @@ -115499,16 +120226,18 @@ def test_delete_calculated_metric_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_create_rollup_property_rest_bad_request( - request_type=analytics_admin.CreateRollupPropertyRequest, +def test_create_subproperty_event_filter_rest_bad_request( + request_type=analytics_admin.CreateSubpropertyEventFilterRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -115523,48 +120252,148 @@ def test_create_rollup_property_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_rollup_property(request) + client.create_subproperty_event_filter(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateRollupPropertyRequest, + analytics_admin.CreateSubpropertyEventFilterRequest, dict, ], ) -def test_create_rollup_property_rest_call_success(request_type): +def test_create_subproperty_event_filter_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {} + request_init = {"parent": "properties/sample1"} + request_init["subproperty_event_filter"] = { + "name": "name_value", + "apply_to_property": "apply_to_property_value", + "filter_clauses": [ + { + "filter_clause_type": 1, + "filter_expression": { + "or_group": {"filter_expressions": {}}, + "not_expression": {}, + "filter_condition": { + "null_filter": True, + "string_filter": { + "match_type": 1, + "value": "value_value", + "case_sensitive": True, + }, + "field_name": "field_name_value", + }, + }, + } + ], + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = analytics_admin.CreateSubpropertyEventFilterRequest.meta.fields[ + "subproperty_event_filter" + ] + + 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[ + "subproperty_event_filter" + ].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["subproperty_event_filter"][field])): + del request_init["subproperty_event_filter"][field][i][subfield] + else: + del request_init["subproperty_event_filter"][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 = analytics_admin.CreateRollupPropertyResponse() + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter( + name="name_value", + apply_to_property="apply_to_property_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 = analytics_admin.CreateRollupPropertyResponse.pb(return_value) + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.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.create_rollup_property(request) + response = client.create_subproperty_event_filter(request) # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.CreateRollupPropertyResponse) + assert isinstance(response, gaa_subproperty_event_filter.SubpropertyEventFilter) + assert response.name == "name_value" + assert response.apply_to_property == "apply_to_property_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_rollup_property_rest_interceptors(null_interceptor): +def test_create_subproperty_event_filter_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -115578,18 +120407,20 @@ def test_create_rollup_property_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_create_rollup_property" + transports.AnalyticsAdminServiceRestInterceptor, + "post_create_subproperty_event_filter", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_rollup_property_with_metadata", + "post_create_subproperty_event_filter_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_create_rollup_property" + transports.AnalyticsAdminServiceRestInterceptor, + "pre_create_subproperty_event_filter", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateRollupPropertyRequest.pb( - analytics_admin.CreateRollupPropertyRequest() + pb_message = analytics_admin.CreateSubpropertyEventFilterRequest.pb( + analytics_admin.CreateSubpropertyEventFilterRequest() ) transcode.return_value = { "method": "post", @@ -115601,24 +120432,24 @@ def test_create_rollup_property_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 = analytics_admin.CreateRollupPropertyResponse.to_json( - analytics_admin.CreateRollupPropertyResponse() + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.to_json( + gaa_subproperty_event_filter.SubpropertyEventFilter() ) req.return_value.content = return_value - request = analytics_admin.CreateRollupPropertyRequest() + request = analytics_admin.CreateSubpropertyEventFilterRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.CreateRollupPropertyResponse() + post.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() post_with_metadata.return_value = ( - analytics_admin.CreateRollupPropertyResponse(), + gaa_subproperty_event_filter.SubpropertyEventFilter(), metadata, ) - client.create_rollup_property( + client.create_subproperty_event_filter( request, metadata=[ ("key", "val"), @@ -115631,14 +120462,14 @@ def test_create_rollup_property_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_rollup_property_source_link_rest_bad_request( - request_type=analytics_admin.GetRollupPropertySourceLinkRequest, +def test_get_subproperty_event_filter_rest_bad_request( + request_type=analytics_admin.GetSubpropertyEventFilterRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/rollupPropertySourceLinks/sample2"} + request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -115653,31 +120484,31 @@ def test_get_rollup_property_source_link_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_rollup_property_source_link(request) + client.get_subproperty_event_filter(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetRollupPropertySourceLinkRequest, + analytics_admin.GetSubpropertyEventFilterRequest, dict, ], ) -def test_get_rollup_property_source_link_rest_call_success(request_type): +def test_get_subproperty_event_filter_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/rollupPropertySourceLinks/sample2"} + request_init = {"name": "properties/sample1/subpropertyEventFilters/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 = resources.RollupPropertySourceLink( + return_value = subproperty_event_filter.SubpropertyEventFilter( name="name_value", - source_property="source_property_value", + apply_to_property="apply_to_property_value", ) # Wrap the value into a proper Response obj @@ -115685,21 +120516,21 @@ def test_get_rollup_property_source_link_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.RollupPropertySourceLink.pb(return_value) + return_value = subproperty_event_filter.SubpropertyEventFilter.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_rollup_property_source_link(request) + response = client.get_subproperty_event_filter(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.RollupPropertySourceLink) + assert isinstance(response, subproperty_event_filter.SubpropertyEventFilter) assert response.name == "name_value" - assert response.source_property == "source_property_value" + assert response.apply_to_property == "apply_to_property_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_rollup_property_source_link_rest_interceptors(null_interceptor): +def test_get_subproperty_event_filter_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -115714,19 +120545,19 @@ def test_get_rollup_property_source_link_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_rollup_property_source_link", + "post_get_subproperty_event_filter", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_rollup_property_source_link_with_metadata", + "post_get_subproperty_event_filter_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_rollup_property_source_link", + "pre_get_subproperty_event_filter", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetRollupPropertySourceLinkRequest.pb( - analytics_admin.GetRollupPropertySourceLinkRequest() + pb_message = analytics_admin.GetSubpropertyEventFilterRequest.pb( + analytics_admin.GetSubpropertyEventFilterRequest() ) transcode.return_value = { "method": "post", @@ -115738,21 +120569,24 @@ def test_get_rollup_property_source_link_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.RollupPropertySourceLink.to_json( - resources.RollupPropertySourceLink() + return_value = subproperty_event_filter.SubpropertyEventFilter.to_json( + subproperty_event_filter.SubpropertyEventFilter() ) req.return_value.content = return_value - request = analytics_admin.GetRollupPropertySourceLinkRequest() + request = analytics_admin.GetSubpropertyEventFilterRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.RollupPropertySourceLink() - post_with_metadata.return_value = resources.RollupPropertySourceLink(), metadata + post.return_value = subproperty_event_filter.SubpropertyEventFilter() + post_with_metadata.return_value = ( + subproperty_event_filter.SubpropertyEventFilter(), + metadata, + ) - client.get_rollup_property_source_link( + client.get_subproperty_event_filter( request, metadata=[ ("key", "val"), @@ -115765,8 +120599,8 @@ def test_get_rollup_property_source_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_rollup_property_source_links_rest_bad_request( - request_type=analytics_admin.ListRollupPropertySourceLinksRequest, +def test_list_subproperty_event_filters_rest_bad_request( + request_type=analytics_admin.ListSubpropertyEventFiltersRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -115787,17 +120621,17 @@ def test_list_rollup_property_source_links_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.list_rollup_property_source_links(request) + client.list_subproperty_event_filters(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListRollupPropertySourceLinksRequest, + analytics_admin.ListSubpropertyEventFiltersRequest, dict, ], ) -def test_list_rollup_property_source_links_rest_call_success(request_type): +def test_list_subproperty_event_filters_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -115809,7 +120643,7 @@ def test_list_rollup_property_source_links_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListRollupPropertySourceLinksResponse( + return_value = analytics_admin.ListSubpropertyEventFiltersResponse( next_page_token="next_page_token_value", ) @@ -115818,22 +120652,22 @@ def test_list_rollup_property_source_links_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListRollupPropertySourceLinksResponse.pb( + return_value = analytics_admin.ListSubpropertyEventFiltersResponse.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_rollup_property_source_links(request) + response = client.list_subproperty_event_filters(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListRollupPropertySourceLinksPager) + assert isinstance(response, pagers.ListSubpropertyEventFiltersPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_rollup_property_source_links_rest_interceptors(null_interceptor): +def test_list_subproperty_event_filters_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -115848,19 +120682,19 @@ def test_list_rollup_property_source_links_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_rollup_property_source_links", + "post_list_subproperty_event_filters", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_rollup_property_source_links_with_metadata", + "post_list_subproperty_event_filters_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_list_rollup_property_source_links", + "pre_list_subproperty_event_filters", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListRollupPropertySourceLinksRequest.pb( - analytics_admin.ListRollupPropertySourceLinksRequest() + pb_message = analytics_admin.ListSubpropertyEventFiltersRequest.pb( + analytics_admin.ListSubpropertyEventFiltersRequest() ) transcode.return_value = { "method": "post", @@ -115872,24 +120706,24 @@ def test_list_rollup_property_source_links_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 = analytics_admin.ListRollupPropertySourceLinksResponse.to_json( - analytics_admin.ListRollupPropertySourceLinksResponse() + return_value = analytics_admin.ListSubpropertyEventFiltersResponse.to_json( + analytics_admin.ListSubpropertyEventFiltersResponse() ) req.return_value.content = return_value - request = analytics_admin.ListRollupPropertySourceLinksRequest() + request = analytics_admin.ListSubpropertyEventFiltersRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListRollupPropertySourceLinksResponse() + post.return_value = analytics_admin.ListSubpropertyEventFiltersResponse() post_with_metadata.return_value = ( - analytics_admin.ListRollupPropertySourceLinksResponse(), + analytics_admin.ListSubpropertyEventFiltersResponse(), metadata, ) - client.list_rollup_property_source_links( + client.list_subproperty_event_filters( request, metadata=[ ("key", "val"), @@ -115902,14 +120736,18 @@ def test_list_rollup_property_source_links_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_rollup_property_source_link_rest_bad_request( - request_type=analytics_admin.CreateRollupPropertySourceLinkRequest, +def test_update_subproperty_event_filter_rest_bad_request( + request_type=analytics_admin.UpdateSubpropertyEventFilterRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} + request_init = { + "subproperty_event_filter": { + "name": "properties/sample1/subpropertyEventFilters/sample2" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -115924,34 +120762,56 @@ def test_create_rollup_property_source_link_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_rollup_property_source_link(request) + client.update_subproperty_event_filter(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateRollupPropertySourceLinkRequest, + analytics_admin.UpdateSubpropertyEventFilterRequest, dict, ], ) -def test_create_rollup_property_source_link_rest_call_success(request_type): +def test_update_subproperty_event_filter_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "properties/sample1"} - request_init["rollup_property_source_link"] = { - "name": "name_value", - "source_property": "source_property_value", + request_init = { + "subproperty_event_filter": { + "name": "properties/sample1/subpropertyEventFilters/sample2" + } + } + request_init["subproperty_event_filter"] = { + "name": "properties/sample1/subpropertyEventFilters/sample2", + "apply_to_property": "apply_to_property_value", + "filter_clauses": [ + { + "filter_clause_type": 1, + "filter_expression": { + "or_group": {"filter_expressions": {}}, + "not_expression": {}, + "filter_condition": { + "null_filter": True, + "string_filter": { + "match_type": 1, + "value": "value_value", + "case_sensitive": True, + }, + "field_name": "field_name_value", + }, + }, + } + ], } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = analytics_admin.CreateRollupPropertySourceLinkRequest.meta.fields[ - "rollup_property_source_link" + test_field = analytics_admin.UpdateSubpropertyEventFilterRequest.meta.fields[ + "subproperty_event_filter" ] def get_message_fields(field): @@ -115981,7 +120841,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime for field, value in request_init[ - "rollup_property_source_link" + "subproperty_event_filter" ].items(): # pragma: NO COVER result = None is_repeated = False @@ -116012,20 +120872,18 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range( - 0, len(request_init["rollup_property_source_link"][field]) - ): - del request_init["rollup_property_source_link"][field][i][subfield] + for i in range(0, len(request_init["subproperty_event_filter"][field])): + del request_init["subproperty_event_filter"][field][i][subfield] else: - del request_init["rollup_property_source_link"][field][subfield] + del request_init["subproperty_event_filter"][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 = resources.RollupPropertySourceLink( + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter( name="name_value", - source_property="source_property_value", + apply_to_property="apply_to_property_value", ) # Wrap the value into a proper Response obj @@ -116033,21 +120891,23 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = resources.RollupPropertySourceLink.pb(return_value) + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.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.create_rollup_property_source_link(request) + response = client.update_subproperty_event_filter(request) # Establish that the response is the type that we expect. - assert isinstance(response, resources.RollupPropertySourceLink) + assert isinstance(response, gaa_subproperty_event_filter.SubpropertyEventFilter) assert response.name == "name_value" - assert response.source_property == "source_property_value" + assert response.apply_to_property == "apply_to_property_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_rollup_property_source_link_rest_interceptors(null_interceptor): +def test_update_subproperty_event_filter_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -116062,19 +120922,19 @@ def test_create_rollup_property_source_link_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_rollup_property_source_link", + "post_update_subproperty_event_filter", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_rollup_property_source_link_with_metadata", + "post_update_subproperty_event_filter_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_create_rollup_property_source_link", + "pre_update_subproperty_event_filter", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateRollupPropertySourceLinkRequest.pb( - analytics_admin.CreateRollupPropertySourceLinkRequest() + pb_message = analytics_admin.UpdateSubpropertyEventFilterRequest.pb( + analytics_admin.UpdateSubpropertyEventFilterRequest() ) transcode.return_value = { "method": "post", @@ -116086,21 +120946,24 @@ def test_create_rollup_property_source_link_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.RollupPropertySourceLink.to_json( - resources.RollupPropertySourceLink() + return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.to_json( + gaa_subproperty_event_filter.SubpropertyEventFilter() ) req.return_value.content = return_value - request = analytics_admin.CreateRollupPropertySourceLinkRequest() + request = analytics_admin.UpdateSubpropertyEventFilterRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = resources.RollupPropertySourceLink() - post_with_metadata.return_value = resources.RollupPropertySourceLink(), metadata + post.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() + post_with_metadata.return_value = ( + gaa_subproperty_event_filter.SubpropertyEventFilter(), + metadata, + ) - client.create_rollup_property_source_link( + client.update_subproperty_event_filter( request, metadata=[ ("key", "val"), @@ -116113,14 +120976,14 @@ def test_create_rollup_property_source_link_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_rollup_property_source_link_rest_bad_request( - request_type=analytics_admin.DeleteRollupPropertySourceLinkRequest, +def test_delete_subproperty_event_filter_rest_bad_request( + request_type=analytics_admin.DeleteSubpropertyEventFilterRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/rollupPropertySourceLinks/sample2"} + request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -116135,23 +120998,23 @@ def test_delete_rollup_property_source_link_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_rollup_property_source_link(request) + client.delete_subproperty_event_filter(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteRollupPropertySourceLinkRequest, + analytics_admin.DeleteSubpropertyEventFilterRequest, dict, ], ) -def test_delete_rollup_property_source_link_rest_call_success(request_type): +def test_delete_subproperty_event_filter_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/rollupPropertySourceLinks/sample2"} + request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -116166,127 +121029,14 @@ def test_delete_rollup_property_source_link_rest_call_success(request_type): 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_rollup_property_source_link(request) + response = client.delete_subproperty_event_filter(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_rollup_property_source_link_rest_interceptors(null_interceptor): - transport = transports.AnalyticsAdminServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.AnalyticsAdminServiceRestInterceptor(), - ) - client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, - "pre_delete_rollup_property_source_link", - ) as pre: - pre.assert_not_called() - pb_message = analytics_admin.DeleteRollupPropertySourceLinkRequest.pb( - analytics_admin.DeleteRollupPropertySourceLinkRequest() - ) - 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"} - - request = analytics_admin.DeleteRollupPropertySourceLinkRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - - client.delete_rollup_property_source_link( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], - ) - - pre.assert_called_once() - - -def test_provision_subproperty_rest_bad_request( - request_type=analytics_admin.ProvisionSubpropertyRequest, -): - client = AnalyticsAdminServiceClient( - 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.provision_subproperty(request) - - -@pytest.mark.parametrize( - "request_type", - [ - analytics_admin.ProvisionSubpropertyRequest, - dict, - ], -) -def test_provision_subproperty_rest_call_success(request_type): - client = AnalyticsAdminServiceClient( - 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 = analytics_admin.ProvisionSubpropertyResponse() - - # 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 = analytics_admin.ProvisionSubpropertyResponse.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.provision_subproperty(request) - - # Establish that the response is the type that we expect. - assert isinstance(response, analytics_admin.ProvisionSubpropertyResponse) - - -@pytest.mark.parametrize("null_interceptor", [True, False]) -def test_provision_subproperty_rest_interceptors(null_interceptor): +def test_delete_subproperty_event_filter_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -116300,18 +121050,12 @@ def test_provision_subproperty_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "post_provision_subproperty" - ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_provision_subproperty_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.AnalyticsAdminServiceRestInterceptor, "pre_provision_subproperty" + "pre_delete_subproperty_event_filter", ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = analytics_admin.ProvisionSubpropertyRequest.pb( - analytics_admin.ProvisionSubpropertyRequest() + pb_message = analytics_admin.DeleteSubpropertyEventFilterRequest.pb( + analytics_admin.DeleteSubpropertyEventFilterRequest() ) transcode.return_value = { "method": "post", @@ -116323,24 +121067,15 @@ def test_provision_subproperty_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 = analytics_admin.ProvisionSubpropertyResponse.to_json( - analytics_admin.ProvisionSubpropertyResponse() - ) - req.return_value.content = return_value - request = analytics_admin.ProvisionSubpropertyRequest() + request = analytics_admin.DeleteSubpropertyEventFilterRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ProvisionSubpropertyResponse() - post_with_metadata.return_value = ( - analytics_admin.ProvisionSubpropertyResponse(), - metadata, - ) - client.provision_subproperty( + client.delete_subproperty_event_filter( request, metadata=[ ("key", "val"), @@ -116349,12 +121084,10 @@ def test_provision_subproperty_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() -def test_create_subproperty_event_filter_rest_bad_request( - request_type=analytics_admin.CreateSubpropertyEventFilterRequest, +def test_create_reporting_data_annotation_rest_bad_request( + request_type=analytics_admin.CreateReportingDataAnnotationRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -116375,52 +121108,39 @@ def test_create_subproperty_event_filter_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_subproperty_event_filter(request) + client.create_reporting_data_annotation(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.CreateSubpropertyEventFilterRequest, + analytics_admin.CreateReportingDataAnnotationRequest, dict, ], ) -def test_create_subproperty_event_filter_rest_call_success(request_type): +def test_create_reporting_data_annotation_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "properties/sample1"} - request_init["subproperty_event_filter"] = { + request_init["reporting_data_annotation"] = { + "annotation_date": {"year": 433, "month": 550, "day": 318}, + "annotation_date_range": {"start_date": {}, "end_date": {}}, "name": "name_value", - "apply_to_property": "apply_to_property_value", - "filter_clauses": [ - { - "filter_clause_type": 1, - "filter_expression": { - "or_group": {"filter_expressions": {}}, - "not_expression": {}, - "filter_condition": { - "null_filter": True, - "string_filter": { - "match_type": 1, - "value": "value_value", - "case_sensitive": True, - }, - "field_name": "field_name_value", - }, - }, - } - ], + "title": "title_value", + "description": "description_value", + "color": 1, + "system_generated": True, } # 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 = analytics_admin.CreateSubpropertyEventFilterRequest.meta.fields[ - "subproperty_event_filter" + test_field = analytics_admin.CreateReportingDataAnnotationRequest.meta.fields[ + "reporting_data_annotation" ] def get_message_fields(field): @@ -116450,7 +121170,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime for field, value in request_init[ - "subproperty_event_filter" + "reporting_data_annotation" ].items(): # pragma: NO COVER result = None is_repeated = False @@ -116481,18 +121201,23 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["subproperty_event_filter"][field])): - del request_init["subproperty_event_filter"][field][i][subfield] + for i in range( + 0, len(request_init["reporting_data_annotation"][field]) + ): + del request_init["reporting_data_annotation"][field][i][subfield] else: - del request_init["subproperty_event_filter"][field][subfield] + del request_init["reporting_data_annotation"][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 = gaa_subproperty_event_filter.SubpropertyEventFilter( + return_value = resources.ReportingDataAnnotation( name="name_value", - apply_to_property="apply_to_property_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, ) # Wrap the value into a proper Response obj @@ -116500,23 +121225,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.ReportingDataAnnotation.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.create_subproperty_event_filter(request) + response = client.create_reporting_data_annotation(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_subproperty_event_filter.SubpropertyEventFilter) + assert isinstance(response, resources.ReportingDataAnnotation) assert response.name == "name_value" - assert response.apply_to_property == "apply_to_property_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_subproperty_event_filter_rest_interceptors(null_interceptor): +def test_create_reporting_data_annotation_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -116531,19 +121257,19 @@ def test_create_subproperty_event_filter_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_subproperty_event_filter", + "post_create_reporting_data_annotation", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_create_subproperty_event_filter_with_metadata", + "post_create_reporting_data_annotation_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_create_subproperty_event_filter", + "pre_create_reporting_data_annotation", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.CreateSubpropertyEventFilterRequest.pb( - analytics_admin.CreateSubpropertyEventFilterRequest() + pb_message = analytics_admin.CreateReportingDataAnnotationRequest.pb( + analytics_admin.CreateReportingDataAnnotationRequest() ) transcode.return_value = { "method": "post", @@ -116555,24 +121281,21 @@ def test_create_subproperty_event_filter_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 = gaa_subproperty_event_filter.SubpropertyEventFilter.to_json( - gaa_subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.ReportingDataAnnotation.to_json( + resources.ReportingDataAnnotation() ) req.return_value.content = return_value - request = analytics_admin.CreateSubpropertyEventFilterRequest() + request = analytics_admin.CreateReportingDataAnnotationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() - post_with_metadata.return_value = ( - gaa_subproperty_event_filter.SubpropertyEventFilter(), - metadata, - ) + post.return_value = resources.ReportingDataAnnotation() + post_with_metadata.return_value = resources.ReportingDataAnnotation(), metadata - client.create_subproperty_event_filter( + client.create_reporting_data_annotation( request, metadata=[ ("key", "val"), @@ -116585,14 +121308,14 @@ def test_create_subproperty_event_filter_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_subproperty_event_filter_rest_bad_request( - request_type=analytics_admin.GetSubpropertyEventFilterRequest, +def test_get_reporting_data_annotation_rest_bad_request( + request_type=analytics_admin.GetReportingDataAnnotationRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} + request_init = {"name": "properties/sample1/reportingDataAnnotations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -116607,31 +121330,34 @@ def test_get_subproperty_event_filter_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_subproperty_event_filter(request) + client.get_reporting_data_annotation(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.GetSubpropertyEventFilterRequest, + analytics_admin.GetReportingDataAnnotationRequest, dict, ], ) -def test_get_subproperty_event_filter_rest_call_success(request_type): +def test_get_reporting_data_annotation_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} + request_init = {"name": "properties/sample1/reportingDataAnnotations/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 = subproperty_event_filter.SubpropertyEventFilter( + return_value = resources.ReportingDataAnnotation( name="name_value", - apply_to_property="apply_to_property_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, ) # Wrap the value into a proper Response obj @@ -116639,21 +121365,24 @@ def test_get_subproperty_event_filter_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = subproperty_event_filter.SubpropertyEventFilter.pb(return_value) + return_value = resources.ReportingDataAnnotation.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_subproperty_event_filter(request) + response = client.get_reporting_data_annotation(request) # Establish that the response is the type that we expect. - assert isinstance(response, subproperty_event_filter.SubpropertyEventFilter) + assert isinstance(response, resources.ReportingDataAnnotation) assert response.name == "name_value" - assert response.apply_to_property == "apply_to_property_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_subproperty_event_filter_rest_interceptors(null_interceptor): +def test_get_reporting_data_annotation_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -116668,19 +121397,19 @@ def test_get_subproperty_event_filter_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_subproperty_event_filter", + "post_get_reporting_data_annotation", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_get_subproperty_event_filter_with_metadata", + "post_get_reporting_data_annotation_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_get_subproperty_event_filter", + "pre_get_reporting_data_annotation", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.GetSubpropertyEventFilterRequest.pb( - analytics_admin.GetSubpropertyEventFilterRequest() + pb_message = analytics_admin.GetReportingDataAnnotationRequest.pb( + analytics_admin.GetReportingDataAnnotationRequest() ) transcode.return_value = { "method": "post", @@ -116692,24 +121421,21 @@ def test_get_subproperty_event_filter_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 = subproperty_event_filter.SubpropertyEventFilter.to_json( - subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.ReportingDataAnnotation.to_json( + resources.ReportingDataAnnotation() ) req.return_value.content = return_value - request = analytics_admin.GetSubpropertyEventFilterRequest() + request = analytics_admin.GetReportingDataAnnotationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = subproperty_event_filter.SubpropertyEventFilter() - post_with_metadata.return_value = ( - subproperty_event_filter.SubpropertyEventFilter(), - metadata, - ) + post.return_value = resources.ReportingDataAnnotation() + post_with_metadata.return_value = resources.ReportingDataAnnotation(), metadata - client.get_subproperty_event_filter( + client.get_reporting_data_annotation( request, metadata=[ ("key", "val"), @@ -116722,8 +121448,8 @@ def test_get_subproperty_event_filter_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_subproperty_event_filters_rest_bad_request( - request_type=analytics_admin.ListSubpropertyEventFiltersRequest, +def test_list_reporting_data_annotations_rest_bad_request( + request_type=analytics_admin.ListReportingDataAnnotationsRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -116744,17 +121470,17 @@ def test_list_subproperty_event_filters_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.list_subproperty_event_filters(request) + client.list_reporting_data_annotations(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.ListSubpropertyEventFiltersRequest, + analytics_admin.ListReportingDataAnnotationsRequest, dict, ], ) -def test_list_subproperty_event_filters_rest_call_success(request_type): +def test_list_reporting_data_annotations_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -116766,7 +121492,7 @@ def test_list_subproperty_event_filters_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = analytics_admin.ListSubpropertyEventFiltersResponse( + return_value = analytics_admin.ListReportingDataAnnotationsResponse( next_page_token="next_page_token_value", ) @@ -116775,22 +121501,22 @@ def test_list_subproperty_event_filters_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = analytics_admin.ListSubpropertyEventFiltersResponse.pb( + return_value = analytics_admin.ListReportingDataAnnotationsResponse.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_subproperty_event_filters(request) + response = client.list_reporting_data_annotations(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListSubpropertyEventFiltersPager) + assert isinstance(response, pagers.ListReportingDataAnnotationsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_subproperty_event_filters_rest_interceptors(null_interceptor): +def test_list_reporting_data_annotations_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -116805,19 +121531,19 @@ def test_list_subproperty_event_filters_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_subproperty_event_filters", + "post_list_reporting_data_annotations", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_list_subproperty_event_filters_with_metadata", + "post_list_reporting_data_annotations_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_list_subproperty_event_filters", + "pre_list_reporting_data_annotations", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.ListSubpropertyEventFiltersRequest.pb( - analytics_admin.ListSubpropertyEventFiltersRequest() + pb_message = analytics_admin.ListReportingDataAnnotationsRequest.pb( + analytics_admin.ListReportingDataAnnotationsRequest() ) transcode.return_value = { "method": "post", @@ -116829,24 +121555,24 @@ def test_list_subproperty_event_filters_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 = analytics_admin.ListSubpropertyEventFiltersResponse.to_json( - analytics_admin.ListSubpropertyEventFiltersResponse() + return_value = analytics_admin.ListReportingDataAnnotationsResponse.to_json( + analytics_admin.ListReportingDataAnnotationsResponse() ) req.return_value.content = return_value - request = analytics_admin.ListSubpropertyEventFiltersRequest() + request = analytics_admin.ListReportingDataAnnotationsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = analytics_admin.ListSubpropertyEventFiltersResponse() + post.return_value = analytics_admin.ListReportingDataAnnotationsResponse() post_with_metadata.return_value = ( - analytics_admin.ListSubpropertyEventFiltersResponse(), + analytics_admin.ListReportingDataAnnotationsResponse(), metadata, ) - client.list_subproperty_event_filters( + client.list_reporting_data_annotations( request, metadata=[ ("key", "val"), @@ -116859,16 +121585,16 @@ def test_list_subproperty_event_filters_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_subproperty_event_filter_rest_bad_request( - request_type=analytics_admin.UpdateSubpropertyEventFilterRequest, +def test_update_reporting_data_annotation_rest_bad_request( + request_type=analytics_admin.UpdateReportingDataAnnotationRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "subproperty_event_filter": { - "name": "properties/sample1/subpropertyEventFilters/sample2" + "reporting_data_annotation": { + "name": "properties/sample1/reportingDataAnnotations/sample2" } } request = request_type(**request_init) @@ -116885,56 +121611,43 @@ def test_update_subproperty_event_filter_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_subproperty_event_filter(request) + client.update_reporting_data_annotation(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.UpdateSubpropertyEventFilterRequest, + analytics_admin.UpdateReportingDataAnnotationRequest, dict, ], ) -def test_update_subproperty_event_filter_rest_call_success(request_type): +def test_update_reporting_data_annotation_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "subproperty_event_filter": { - "name": "properties/sample1/subpropertyEventFilters/sample2" + "reporting_data_annotation": { + "name": "properties/sample1/reportingDataAnnotations/sample2" } } - request_init["subproperty_event_filter"] = { - "name": "properties/sample1/subpropertyEventFilters/sample2", - "apply_to_property": "apply_to_property_value", - "filter_clauses": [ - { - "filter_clause_type": 1, - "filter_expression": { - "or_group": {"filter_expressions": {}}, - "not_expression": {}, - "filter_condition": { - "null_filter": True, - "string_filter": { - "match_type": 1, - "value": "value_value", - "case_sensitive": True, - }, - "field_name": "field_name_value", - }, - }, - } - ], + request_init["reporting_data_annotation"] = { + "annotation_date": {"year": 433, "month": 550, "day": 318}, + "annotation_date_range": {"start_date": {}, "end_date": {}}, + "name": "properties/sample1/reportingDataAnnotations/sample2", + "title": "title_value", + "description": "description_value", + "color": 1, + "system_generated": True, } # 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 = analytics_admin.UpdateSubpropertyEventFilterRequest.meta.fields[ - "subproperty_event_filter" + test_field = analytics_admin.UpdateReportingDataAnnotationRequest.meta.fields[ + "reporting_data_annotation" ] def get_message_fields(field): @@ -116964,7 +121677,7 @@ def get_message_fields(field): # For each item in the sample request, create a list of sub fields which are not present at runtime # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime for field, value in request_init[ - "subproperty_event_filter" + "reporting_data_annotation" ].items(): # pragma: NO COVER result = None is_repeated = False @@ -116995,18 +121708,23 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["subproperty_event_filter"][field])): - del request_init["subproperty_event_filter"][field][i][subfield] + for i in range( + 0, len(request_init["reporting_data_annotation"][field]) + ): + del request_init["reporting_data_annotation"][field][i][subfield] else: - del request_init["subproperty_event_filter"][field][subfield] + del request_init["reporting_data_annotation"][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 = gaa_subproperty_event_filter.SubpropertyEventFilter( + return_value = resources.ReportingDataAnnotation( name="name_value", - apply_to_property="apply_to_property_value", + title="title_value", + description="description_value", + color=resources.ReportingDataAnnotation.Color.PURPLE, + system_generated=True, ) # Wrap the value into a proper Response obj @@ -117014,23 +121732,24 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gaa_subproperty_event_filter.SubpropertyEventFilter.pb( - return_value - ) + return_value = resources.ReportingDataAnnotation.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_subproperty_event_filter(request) + response = client.update_reporting_data_annotation(request) # Establish that the response is the type that we expect. - assert isinstance(response, gaa_subproperty_event_filter.SubpropertyEventFilter) + assert isinstance(response, resources.ReportingDataAnnotation) assert response.name == "name_value" - assert response.apply_to_property == "apply_to_property_value" + assert response.title == "title_value" + assert response.description == "description_value" + assert response.color == resources.ReportingDataAnnotation.Color.PURPLE + assert response.system_generated is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_subproperty_event_filter_rest_interceptors(null_interceptor): +def test_update_reporting_data_annotation_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -117045,19 +121764,19 @@ def test_update_subproperty_event_filter_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_subproperty_event_filter", + "post_update_reporting_data_annotation", ) as post, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "post_update_subproperty_event_filter_with_metadata", + "post_update_reporting_data_annotation_with_metadata", ) as post_with_metadata, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_update_subproperty_event_filter", + "pre_update_reporting_data_annotation", ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = analytics_admin.UpdateSubpropertyEventFilterRequest.pb( - analytics_admin.UpdateSubpropertyEventFilterRequest() + pb_message = analytics_admin.UpdateReportingDataAnnotationRequest.pb( + analytics_admin.UpdateReportingDataAnnotationRequest() ) transcode.return_value = { "method": "post", @@ -117069,24 +121788,21 @@ def test_update_subproperty_event_filter_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 = gaa_subproperty_event_filter.SubpropertyEventFilter.to_json( - gaa_subproperty_event_filter.SubpropertyEventFilter() + return_value = resources.ReportingDataAnnotation.to_json( + resources.ReportingDataAnnotation() ) req.return_value.content = return_value - request = analytics_admin.UpdateSubpropertyEventFilterRequest() + request = analytics_admin.UpdateReportingDataAnnotationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gaa_subproperty_event_filter.SubpropertyEventFilter() - post_with_metadata.return_value = ( - gaa_subproperty_event_filter.SubpropertyEventFilter(), - metadata, - ) + post.return_value = resources.ReportingDataAnnotation() + post_with_metadata.return_value = resources.ReportingDataAnnotation(), metadata - client.update_subproperty_event_filter( + client.update_reporting_data_annotation( request, metadata=[ ("key", "val"), @@ -117099,14 +121815,14 @@ def test_update_subproperty_event_filter_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_subproperty_event_filter_rest_bad_request( - request_type=analytics_admin.DeleteSubpropertyEventFilterRequest, +def test_delete_reporting_data_annotation_rest_bad_request( + request_type=analytics_admin.DeleteReportingDataAnnotationRequest, ): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} + request_init = {"name": "properties/sample1/reportingDataAnnotations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -117121,23 +121837,23 @@ def test_delete_subproperty_event_filter_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_subproperty_event_filter(request) + client.delete_reporting_data_annotation(request) @pytest.mark.parametrize( "request_type", [ - analytics_admin.DeleteSubpropertyEventFilterRequest, + analytics_admin.DeleteReportingDataAnnotationRequest, dict, ], ) -def test_delete_subproperty_event_filter_rest_call_success(request_type): +def test_delete_reporting_data_annotation_rest_call_success(request_type): client = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "properties/sample1/subpropertyEventFilters/sample2"} + request_init = {"name": "properties/sample1/reportingDataAnnotations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -117152,14 +121868,14 @@ def test_delete_subproperty_event_filter_rest_call_success(request_type): 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_subproperty_event_filter(request) + response = client.delete_reporting_data_annotation(request) # Establish that the response is the type that we expect. assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_subproperty_event_filter_rest_interceptors(null_interceptor): +def test_delete_reporting_data_annotation_rest_interceptors(null_interceptor): transport = transports.AnalyticsAdminServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -117174,11 +121890,11 @@ def test_delete_subproperty_event_filter_rest_interceptors(null_interceptor): path_template, "transcode" ) as transcode, mock.patch.object( transports.AnalyticsAdminServiceRestInterceptor, - "pre_delete_subproperty_event_filter", + "pre_delete_reporting_data_annotation", ) as pre: pre.assert_not_called() - pb_message = analytics_admin.DeleteSubpropertyEventFilterRequest.pb( - analytics_admin.DeleteSubpropertyEventFilterRequest() + pb_message = analytics_admin.DeleteReportingDataAnnotationRequest.pb( + analytics_admin.DeleteReportingDataAnnotationRequest() ) transcode.return_value = { "method": "post", @@ -117191,14 +121907,14 @@ def test_delete_subproperty_event_filter_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = analytics_admin.DeleteSubpropertyEventFilterRequest() + request = analytics_admin.DeleteReportingDataAnnotationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_subproperty_event_filter( + client.delete_reporting_data_annotation( request, metadata=[ ("key", "val"), @@ -117209,6 +121925,136 @@ def test_delete_subproperty_event_filter_rest_interceptors(null_interceptor): pre.assert_called_once() +def test_submit_user_deletion_rest_bad_request( + request_type=analytics_admin.SubmitUserDeletionRequest, +): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "properties/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.submit_user_deletion(request) + + +@pytest.mark.parametrize( + "request_type", + [ + analytics_admin.SubmitUserDeletionRequest, + dict, + ], +) +def test_submit_user_deletion_rest_call_success(request_type): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "properties/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 = analytics_admin.SubmitUserDeletionResponse() + + # 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 = analytics_admin.SubmitUserDeletionResponse.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.submit_user_deletion(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, analytics_admin.SubmitUserDeletionResponse) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_submit_user_deletion_rest_interceptors(null_interceptor): + transport = transports.AnalyticsAdminServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.AnalyticsAdminServiceRestInterceptor(), + ) + client = AnalyticsAdminServiceClient(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.AnalyticsAdminServiceRestInterceptor, "post_submit_user_deletion" + ) as post, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, + "post_submit_user_deletion_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.AnalyticsAdminServiceRestInterceptor, "pre_submit_user_deletion" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = analytics_admin.SubmitUserDeletionRequest.pb( + analytics_admin.SubmitUserDeletionRequest() + ) + 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 = analytics_admin.SubmitUserDeletionResponse.to_json( + analytics_admin.SubmitUserDeletionResponse() + ) + req.return_value.content = return_value + + request = analytics_admin.SubmitUserDeletionRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = analytics_admin.SubmitUserDeletionResponse() + post_with_metadata.return_value = ( + analytics_admin.SubmitUserDeletionResponse(), + metadata, + ) + + client.submit_user_deletion( + 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 = AnalyticsAdminServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -120491,6 +125337,138 @@ def test_delete_subproperty_event_filter_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_create_reporting_data_annotation_empty_call_rest(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reporting_data_annotation), "__call__" + ) as call: + client.create_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.CreateReportingDataAnnotationRequest() + + 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_reporting_data_annotation_empty_call_rest(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_reporting_data_annotation), "__call__" + ) as call: + client.get_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.GetReportingDataAnnotationRequest() + + 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_reporting_data_annotations_empty_call_rest(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reporting_data_annotations), "__call__" + ) as call: + client.list_reporting_data_annotations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.ListReportingDataAnnotationsRequest() + + 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_reporting_data_annotation_empty_call_rest(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_reporting_data_annotation), "__call__" + ) as call: + client.update_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.UpdateReportingDataAnnotationRequest() + + 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_reporting_data_annotation_empty_call_rest(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reporting_data_annotation), "__call__" + ) as call: + client.delete_reporting_data_annotation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.DeleteReportingDataAnnotationRequest() + + 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_submit_user_deletion_empty_call_rest(): + client = AnalyticsAdminServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.submit_user_deletion), "__call__" + ) as call: + client.submit_user_deletion(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = analytics_admin.SubmitUserDeletionRequest() + + assert args[0] == request_msg + + def test_transport_grpc_default(): # A client should use the gRPC transport by default. client = AnalyticsAdminServiceClient( @@ -120674,6 +125652,12 @@ def test_analytics_admin_service_base_transport(): "list_subproperty_event_filters", "update_subproperty_event_filter", "delete_subproperty_event_filter", + "create_reporting_data_annotation", + "get_reporting_data_annotation", + "list_reporting_data_annotations", + "update_reporting_data_annotation", + "delete_reporting_data_annotation", + "submit_user_deletion", ) for method in methods: with pytest.raises(NotImplementedError): @@ -121426,6 +126410,24 @@ def test_analytics_admin_service_client_transport_session_collision(transport_na session1 = client1.transport.delete_subproperty_event_filter._session session2 = client2.transport.delete_subproperty_event_filter._session assert session1 != session2 + session1 = client1.transport.create_reporting_data_annotation._session + session2 = client2.transport.create_reporting_data_annotation._session + assert session1 != session2 + session1 = client1.transport.get_reporting_data_annotation._session + session2 = client2.transport.get_reporting_data_annotation._session + assert session1 != session2 + session1 = client1.transport.list_reporting_data_annotations._session + session2 = client2.transport.list_reporting_data_annotations._session + assert session1 != session2 + session1 = client1.transport.update_reporting_data_annotation._session + session2 = client2.transport.update_reporting_data_annotation._session + assert session1 != session2 + session1 = client1.transport.delete_reporting_data_annotation._session + session2 = client2.transport.delete_reporting_data_annotation._session + assert session1 != session2 + session1 = client1.transport.submit_user_deletion._session + session2 = client2.transport.submit_user_deletion._session + assert session1 != session2 def test_analytics_admin_service_grpc_transport_channel(): @@ -122259,9 +127261,34 @@ def test_parse_property_path(): assert expected == actual -def test_rollup_property_source_link_path(): +def test_reporting_data_annotation_path(): property = "whelk" - rollup_property_source_link = "octopus" + reporting_data_annotation = "octopus" + expected = "properties/{property}/reportingDataAnnotations/{reporting_data_annotation}".format( + property=property, + reporting_data_annotation=reporting_data_annotation, + ) + actual = AnalyticsAdminServiceClient.reporting_data_annotation_path( + property, reporting_data_annotation + ) + assert expected == actual + + +def test_parse_reporting_data_annotation_path(): + expected = { + "property": "oyster", + "reporting_data_annotation": "nudibranch", + } + path = AnalyticsAdminServiceClient.reporting_data_annotation_path(**expected) + + # Check that the path construction is reversible. + actual = AnalyticsAdminServiceClient.parse_reporting_data_annotation_path(path) + assert expected == actual + + +def test_rollup_property_source_link_path(): + property = "cuttlefish" + rollup_property_source_link = "mussel" expected = "properties/{property}/rollupPropertySourceLinks/{rollup_property_source_link}".format( property=property, rollup_property_source_link=rollup_property_source_link, @@ -122274,8 +127301,8 @@ def test_rollup_property_source_link_path(): def test_parse_rollup_property_source_link_path(): expected = { - "property": "oyster", - "rollup_property_source_link": "nudibranch", + "property": "winkle", + "rollup_property_source_link": "nautilus", } path = AnalyticsAdminServiceClient.rollup_property_source_link_path(**expected) @@ -122285,8 +127312,8 @@ def test_parse_rollup_property_source_link_path(): def test_search_ads360_link_path(): - property = "cuttlefish" - search_ads_360_link = "mussel" + property = "scallop" + search_ads_360_link = "abalone" expected = "properties/{property}/searchAds360Links/{search_ads_360_link}".format( property=property, search_ads_360_link=search_ads_360_link, @@ -122299,8 +127326,8 @@ def test_search_ads360_link_path(): def test_parse_search_ads360_link_path(): expected = { - "property": "winkle", - "search_ads_360_link": "nautilus", + "property": "squid", + "search_ads_360_link": "clam", } path = AnalyticsAdminServiceClient.search_ads360_link_path(**expected) @@ -122310,9 +127337,9 @@ def test_parse_search_ads360_link_path(): def test_sk_ad_network_conversion_value_schema_path(): - property = "scallop" - data_stream = "abalone" - skadnetwork_conversion_value_schema = "squid" + property = "whelk" + data_stream = "octopus" + skadnetwork_conversion_value_schema = "oyster" expected = "properties/{property}/dataStreams/{data_stream}/sKAdNetworkConversionValueSchema/{skadnetwork_conversion_value_schema}".format( property=property, data_stream=data_stream, @@ -122326,9 +127353,9 @@ def test_sk_ad_network_conversion_value_schema_path(): def test_parse_sk_ad_network_conversion_value_schema_path(): expected = { - "property": "clam", - "data_stream": "whelk", - "skadnetwork_conversion_value_schema": "octopus", + "property": "nudibranch", + "data_stream": "cuttlefish", + "skadnetwork_conversion_value_schema": "mussel", } path = AnalyticsAdminServiceClient.sk_ad_network_conversion_value_schema_path( **expected @@ -122344,8 +127371,8 @@ def test_parse_sk_ad_network_conversion_value_schema_path(): def test_subproperty_event_filter_path(): - property = "oyster" - sub_property_event_filter = "nudibranch" + property = "winkle" + sub_property_event_filter = "nautilus" expected = "properties/{property}/subpropertyEventFilters/{sub_property_event_filter}".format( property=property, sub_property_event_filter=sub_property_event_filter, @@ -122358,8 +127385,8 @@ def test_subproperty_event_filter_path(): def test_parse_subproperty_event_filter_path(): expected = { - "property": "cuttlefish", - "sub_property_event_filter": "mussel", + "property": "scallop", + "sub_property_event_filter": "abalone", } path = AnalyticsAdminServiceClient.subproperty_event_filter_path(**expected) @@ -122369,7 +127396,7 @@ def test_parse_subproperty_event_filter_path(): def test_common_billing_account_path(): - billing_account = "winkle" + billing_account = "squid" expected = "billingAccounts/{billing_account}".format( billing_account=billing_account, ) @@ -122379,7 +127406,7 @@ def test_common_billing_account_path(): def test_parse_common_billing_account_path(): expected = { - "billing_account": "nautilus", + "billing_account": "clam", } path = AnalyticsAdminServiceClient.common_billing_account_path(**expected) @@ -122389,7 +127416,7 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): - folder = "scallop" + folder = "whelk" expected = "folders/{folder}".format( folder=folder, ) @@ -122399,7 +127426,7 @@ def test_common_folder_path(): def test_parse_common_folder_path(): expected = { - "folder": "abalone", + "folder": "octopus", } path = AnalyticsAdminServiceClient.common_folder_path(**expected) @@ -122409,7 +127436,7 @@ def test_parse_common_folder_path(): def test_common_organization_path(): - organization = "squid" + organization = "oyster" expected = "organizations/{organization}".format( organization=organization, ) @@ -122419,7 +127446,7 @@ def test_common_organization_path(): def test_parse_common_organization_path(): expected = { - "organization": "clam", + "organization": "nudibranch", } path = AnalyticsAdminServiceClient.common_organization_path(**expected) @@ -122429,7 +127456,7 @@ def test_parse_common_organization_path(): def test_common_project_path(): - project = "whelk" + project = "cuttlefish" expected = "projects/{project}".format( project=project, ) @@ -122439,7 +127466,7 @@ def test_common_project_path(): def test_parse_common_project_path(): expected = { - "project": "octopus", + "project": "mussel", } path = AnalyticsAdminServiceClient.common_project_path(**expected) @@ -122449,8 +127476,8 @@ def test_parse_common_project_path(): def test_common_location_path(): - project = "oyster" - location = "nudibranch" + project = "winkle" + location = "nautilus" expected = "projects/{project}/locations/{location}".format( project=project, location=location, @@ -122461,8 +127488,8 @@ def test_common_location_path(): def test_parse_common_location_path(): expected = { - "project": "cuttlefish", - "location": "mussel", + "project": "scallop", + "location": "abalone", } path = AnalyticsAdminServiceClient.common_location_path(**expected)